Rollup merge of #140607 - lcnr:opaque-type-storage, r=compiler-errors

support duplicate entries in the opaque_type_storage
Necessary for the new solver as we may unify keys when eagerly resolving for canonical queries. See the relevant comment when instantiating query responses:
```rust
// We eagerly resolve inference variables when computing the query response.
// This can cause previously distinct opaque type keys to now be structurally equal.
//
// To handle this, we store any duplicate entries in a separate list to check them
// at the end of typeck/borrowck. We could alternatively eagerly equate the hidden
// types here. However, doing so is difficult as it may result in nested goals and
// any errors may make it harder to track the control flow for diagnostics.
if let Some(prev) = prev {
self.delegate.add_duplicate_opaque_type(key, prev, self.origin_span);
}
```
This will be far more relevant with #140497.
r? `@compiler-errors`

Author: jhpratt

Cargo.lock

@@ -4516,7 +4516,6 @@ dependencies = [
 "rustc_session",
 "rustc_span",
 "rustc_transmute",
-"rustc_type_ir",
 "smallvec",
 "thin-vec",
 "tracing",

compiler/rustc_hir_typeck/src/_match.rs

@@ -603,7 +603,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 // FIXME(-Znext-solver): Remove this branch once `replace_opaque_types_with_infer` is gone.
  ty::Infer(ty::TyVar(_)) => self
 .inner
-.borrow()
+.borrow_mut()
+.opaque_types()
 .iter_opaque_types()
 .find(|(_, v)| v.ty == expected_ty)
 .map(|(k, _)| (k.def_id, k.args))?,

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -132,7 +132,13 @@ impl<'tcx> InferCtxt<'tcx> {
 
 let certainty = if errors.is_empty(){Certainty::Proven}else{Certainty::Ambiguous};
 
-let opaque_types = self.take_opaque_types_for_query_response();
+let opaque_types = self
+.inner
+.borrow_mut()
+.opaque_type_storage
+.take_opaque_types()
+.map(|(k, v)| (k, v.ty))
+.collect();
 
 Ok(QueryResponse{
 var_values: inference_vars,
@@ -143,24 +149,6 @@ impl<'tcx> InferCtxt<'tcx> {
 })
 }
 
-/// Used by the new solver as that one takes the opaque types at the end of a probe
-/// to deal with multiple candidates without having to recompute them.
-pubfnclone_opaque_types_for_query_response(
-&self,
-) -> Vec<(ty::OpaqueTypeKey<'tcx>,Ty<'tcx>)>{
-self.inner
-.borrow()
-.opaque_type_storage
-.opaque_types
-.iter()
-.map(|(k, v)| (*k, v.ty))
-.collect()
-}
-
-fntake_opaque_types_for_query_response(&self) -> Vec<(ty::OpaqueTypeKey<'tcx>,Ty<'tcx>)>{
-self.take_opaque_types().into_iter().map(|(k, v)| (k, v.ty)).collect()
-}
-
 /// Given the (canonicalized) result to a canonical query,
 /// instantiates the result so it can be used, plugging in the
 /// values from the canonical query. (Note that the result may

compiler/rustc_infer/src/infer/mod.rs

@@ -31,9 +31,9 @@ use rustc_middle::traits::solve::Goal;
 use rustc_middle::ty::error::{ExpectedFound,TypeError};
 use rustc_middle::ty::{
 self,BoundVarReplacerDelegate,ConstVid,FloatVid,GenericArg,GenericArgKind,GenericArgs,
-GenericArgsRef,GenericParamDefKind,InferConst,IntVid,PseudoCanonicalInput,Term,TermKind,
-Ty,TyCtxt,TyVid,TypeFoldable,TypeFolder,TypeSuperFoldable,TypeVisitable,
-TypeVisitableExt,TypingEnv,TypingMode, fold_regions,
+GenericArgsRef,GenericParamDefKind,InferConst,IntVid,OpaqueHiddenType,OpaqueTypeKey,
+PseudoCanonicalInput,Term,TermKind,Ty,TyCtxt,TyVid,TypeFoldable,TypeFolder,
+TypeSuperFoldable,TypeVisitable,TypeVisitableExt,TypingEnv,TypingMode, fold_regions,
 };
 use rustc_span::{Span,Symbol};
 use snapshot::undo_log::InferCtxtUndoLogs;
@@ -198,7 +198,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
 }
 
 #[inline]
-fnopaque_types(&mutself) -> opaque_types::OpaqueTypeTable<'_,'tcx>{
+pubfnopaque_types(&mutself) -> opaque_types::OpaqueTypeTable<'_,'tcx>{
 self.opaque_type_storage.with_log(&mutself.undo_log)
 }
 
@@ -224,15 +224,6 @@ impl<'tcx> InferCtxtInner<'tcx> {
 .expect("region constraints already solved")
 .with_log(&mutself.undo_log)
 }
-
-// Iterates through the opaque type definitions without taking them; this holds the
-// `InferCtxtInner` lock, so make sure to not do anything with `InferCtxt` side-effects
-// while looping through this.
-pubfniter_opaque_types(
-&self,
-) -> implIterator<Item = (ty::OpaqueTypeKey<'tcx>, ty::OpaqueHiddenType<'tcx>)>{
-self.opaque_type_storage.opaque_types.iter().map(|(&k,&v)| (k, v))
-}
 }
 
 pubstructInferCtxt<'tcx>{
@@ -954,13 +945,13 @@ impl<'tcx> InferCtxt<'tcx> {
 }
 
 #[instrument(level = "debug", skip(self), ret)]
-pubfntake_opaque_types(&self) -> opaque_types::OpaqueTypeMap<'tcx>{
-std::mem::take(&mutself.inner.borrow_mut().opaque_type_storage.opaque_types)
+pubfntake_opaque_types(&self) -> Vec<(OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>)>{
+self.inner.borrow_mut().opaque_type_storage.take_opaque_types().collect()
 }
 
 #[instrument(level = "debug", skip(self), ret)]
-pubfnclone_opaque_types(&self) -> opaque_types::OpaqueTypeMap<'tcx>{
-self.inner.borrow().opaque_type_storage.opaque_types.clone()
+pubfnclone_opaque_types(&self) -> Vec<(OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>)>{
+self.inner.borrow_mut().opaque_type_storage.iter_opaque_types().collect()
 }
 
 #[inline(always)]

compiler/rustc_infer/src/infer/opaque_types/mod.rs

@@ -1,5 +1,4 @@
 use hir::def_id::{DefId,LocalDefId};
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir as hir;
 use rustc_middle::bug;
 use rustc_middle::traits::ObligationCause;
@@ -19,7 +18,6 @@ use crate::traits::{self, Obligation, PredicateObligations};
 
 mod table;
 
-pub(crate)typeOpaqueTypeMap<'tcx> = FxIndexMap<OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>>;
 pub(crate)use table::{OpaqueTypeStorage,OpaqueTypeTable};
 
 impl<'tcx>InferCtxt<'tcx>{

compiler/rustc_infer/src/infer/opaque_types/table.rs

@@ -1,18 +1,17 @@
+use std::ops::Deref;
+
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::undo_log::UndoLogs;
 use rustc_middle::bug;
 use rustc_middle::ty::{self,OpaqueHiddenType,OpaqueTypeKey,Ty};
 use tracing::instrument;
 
-usesuper::OpaqueTypeMap;
 usecrate::infer::snapshot::undo_log::{InferCtxtUndoLogs,UndoLog};
 
 #[derive(Default,Debug,Clone)]
-pub(crate)structOpaqueTypeStorage<'tcx>{
-/// Opaque types found in explicit return types and their
-/// associated fresh inference variable. Writeback resolves these
-/// variables to get the concrete type, which can be used to
-/// 'de-opaque' OpaqueHiddenType, after typeck is done with all functions.
-pubopaque_types:OpaqueTypeMap<'tcx>,
+pubstructOpaqueTypeStorage<'tcx>{
+opaque_types:FxIndexMap<OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>>,
+duplicate_entries:Vec<(OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>)>,
 }
 
 impl<'tcx>OpaqueTypeStorage<'tcx>{
@@ -33,6 +32,52 @@ impl<'tcx> OpaqueTypeStorage<'tcx> {
 }
 }
 
+pub(crate)fnpop_duplicate_entry(&mutself){
+let entry = self.duplicate_entries.pop();
+assert!(entry.is_some());
+}
+
+pub(crate)fnis_empty(&self) -> bool{
+letOpaqueTypeStorage{ opaque_types, duplicate_entries } = self;
+ opaque_types.is_empty() && duplicate_entries.is_empty()
+}
+
+pub(crate)fntake_opaque_types(
+&mutself,
+) -> implIterator<Item = (OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>)>{
+letOpaqueTypeStorage{ opaque_types, duplicate_entries } = self;
+ std::mem::take(opaque_types).into_iter().chain(std::mem::take(duplicate_entries))
+}
+
+/// Only returns the opaque types from the lookup table. These are used
+/// when normalizing opaque types and have a unique key.
+///
+/// Outside of canonicalization one should generally use `iter_opaque_types`
+/// to also consider duplicate entries.
+pubfniter_lookup_table(
+&self,
+) -> implIterator<Item = (OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>)>{
+self.opaque_types.iter().map(|(k, v)| (*k,*v))
+}
+
+/// Only returns the opaque types which are stored in `duplicate_entries`.
+///
+/// These have to considered when checking all opaque type uses but are e.g.
+/// irrelevant for canonical inputs as nested queries never meaningfully
+/// accesses them.
+pubfniter_duplicate_entries(
+&self,
+) -> implIterator<Item = (OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>)>{
+self.duplicate_entries.iter().copied()
+}
+
+pubfniter_opaque_types(
+&self,
+) -> implIterator<Item = (OpaqueTypeKey<'tcx>,OpaqueHiddenType<'tcx>)>{
+letOpaqueTypeStorage{ opaque_types, duplicate_entries } = self;
+ opaque_types.iter().map(|(k, v)| (*k,*v)).chain(duplicate_entries.iter().copied())
+}
+
 #[inline]
 pub(crate)fnwith_log<'a>(
 &'amutself,
@@ -44,21 +89,27 @@ impl<'tcx> OpaqueTypeStorage<'tcx> {
 
 impl<'tcx>DropforOpaqueTypeStorage<'tcx>{
 fndrop(&mutself){
-if !self.opaque_types.is_empty(){
+if !self.is_empty(){
  ty::tls::with(|tcx| tcx.dcx().delayed_bug(format!("{:?}",self.opaque_types)));
 }
 }
 }
 
-pub(crate)structOpaqueTypeTable<'a,'tcx>{
+pubstructOpaqueTypeTable<'a,'tcx>{
 storage:&'amutOpaqueTypeStorage<'tcx>,
 
 undo_log:&'amutInferCtxtUndoLogs<'tcx>,
 }
+impl<'tcx>DerefforOpaqueTypeTable<'_,'tcx>{
+typeTarget = OpaqueTypeStorage<'tcx>;
+fnderef(&self) -> &Self::Target{
+self.storage
+}
+}
 
 impl<'a,'tcx>OpaqueTypeTable<'a,'tcx>{
 #[instrument(skip(self), level = "debug")]
-pub(crate)fnregister(
+pubfnregister(
 &mutself,
 key:OpaqueTypeKey<'tcx>,
 hidden_type:OpaqueHiddenType<'tcx>,
@@ -72,4 +123,9 @@ impl<'a, 'tcx> OpaqueTypeTable<'a, 'tcx> {
 self.undo_log.push(UndoLog::OpaqueTypes(key,None));
 None
 }
+
+pubfnadd_duplicate(&mutself,key:OpaqueTypeKey<'tcx>,hidden_type:OpaqueHiddenType<'tcx>){
+self.storage.duplicate_entries.push((key, hidden_type));
+self.undo_log.push(UndoLog::DuplicateOpaqueType);
+}
 }

compiler/rustc_infer/src/infer/snapshot/undo_log.rs

@@ -17,6 +17,7 @@ pub struct Snapshot<'tcx> {
 /// Records the "undo" data for a single operation that affects some form of inference variable.
 #[derive(Clone)]
 pub(crate)enumUndoLog<'tcx>{
+DuplicateOpaqueType,
 OpaqueTypes(OpaqueTypeKey<'tcx>,Option<OpaqueHiddenType<'tcx>>),
 TypeVariables(sv::UndoLog<ut::Delegate<type_variable::TyVidEqKey<'tcx>>>),
 ConstUnificationTable(sv::UndoLog<ut::Delegate<ConstVidKey<'tcx>>>),
@@ -58,6 +59,7 @@ impl_from! {
 impl<'tcx>Rollback<UndoLog<'tcx>>forInferCtxtInner<'tcx>{
 fnreverse(&mutself,undo:UndoLog<'tcx>){
 match undo {
+UndoLog::DuplicateOpaqueType => self.opaque_type_storage.pop_duplicate_entry(),
 UndoLog::OpaqueTypes(key, idx) => self.opaque_type_storage.remove(key, idx),
 UndoLog::TypeVariables(undo) => self.type_variable_storage.reverse(undo),
 UndoLog::ConstUnificationTable(undo) => self.const_unification_storage.reverse(undo),

compiler/rustc_next_trait_solver/src/delegate.rs

@@ -39,7 +39,10 @@ pub trait SolverDelegate: Deref<Target = Self::Infcx> + Sized {
 term: <Self::InternerasInterner>::Term,
 ) -> Option<Vec<Goal<Self::Interner, <Self::InternerasInterner>::Predicate>>>;
 
-fnclone_opaque_types_for_query_response(
+fnclone_opaque_types_lookup_table(
+&self,
+) -> Vec<(ty::OpaqueTypeKey<Self::Interner>, <Self::InternerasInterner>::Ty)>;
+fnclone_duplicate_opaque_types(
 &self,
 ) -> Vec<(ty::OpaqueTypeKey<Self::Interner>, <Self::InternerasInterner>::Ty)>;
 
@@ -68,6 +71,12 @@ pub trait SolverDelegate: Deref<Target = Self::Infcx> + Sized {
 hidden_ty: <Self::InternerasInterner>::Ty,
 span: <Self::InternerasInterner>::Span,
 ) -> Option<<Self::InternerasInterner>::Ty>;
+fnadd_duplicate_opaque_type(
+&self,
+opaque_type_key: ty::OpaqueTypeKey<Self::Interner>,
+hidden_ty: <Self::InternerasInterner>::Ty,
+span: <Self::InternerasInterner>::Span,
+);
 
 fnadd_item_bounds_for_hidden_type(
 &self,

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs

@@ -56,7 +56,10 @@ where
 &self,
 goal:Goal<I,T>,
 ) -> (Vec<I::GenericArg>,CanonicalInput<I,T>){
-let opaque_types = self.delegate.clone_opaque_types_for_query_response();
+// We only care about one entry per `OpaqueTypeKey` here,
+// so we only canonicalize the lookup table and ignore
+// duplicate entries.
+let opaque_types = self.delegate.clone_opaque_types_lookup_table();
 let(goal, opaque_types) =
 (goal, opaque_types).fold_with(&mutEagerResolver::new(self.delegate));
 
@@ -241,19 +244,21 @@ where
 Default::default()
 };
 
-ExternalConstraintsData{
- region_constraints,
-opaque_types:self
-.delegate
-.clone_opaque_types_for_query_response()
-.into_iter()
-// Only return *newly defined* opaque types.
-.filter(|(a, _)| {
-self.predefined_opaques_in_body.opaque_types.iter().all(|(pa, _)| pa != a)
-})
-.collect(),
- normalization_nested_goals,
-}
+// We only return *newly defined* opaque types from canonical queries.
+//
+// Constraints for any existing opaque types are already tracked by changes
+// to the `var_values`.
+let opaque_types = self
+.delegate
+.clone_opaque_types_lookup_table()
+.into_iter()
+.filter(|(a, _)| {
+self.predefined_opaques_in_body.opaque_types.iter().all(|(pa, _)| pa != a)
+})
+.chain(self.delegate.clone_duplicate_opaque_types())
+.collect();
+
+ExternalConstraintsData{ region_constraints, opaque_types, normalization_nested_goals }
 }
 
 /// After calling a canonical query, we apply the constraints returned
@@ -432,7 +437,16 @@ where
 fnregister_new_opaque_types(&mutself,opaque_types:&[(ty::OpaqueTypeKey<I>,I::Ty)]){
 for&(key, ty)in opaque_types {
 let prev = self.delegate.register_hidden_type_in_storage(key, ty,self.origin_span);
-assert_eq!(prev,None);
+// We eagerly resolve inference variables when computing the query response.
+// This can cause previously distinct opaque type keys to now be structurally equal.
+//
+// To handle this, we store any duplicate entries in a separate list to check them
+// at the end of typeck/borrowck. We could alternatively eagerly equate the hidden
+// types here. However, doing so is difficult as it may result in nested goals and
+// any errors may make it harder to track the control flow for diagnostics.
+ifletSome(prev) = prev {
+self.delegate.add_duplicate_opaque_type(key, prev,self.origin_span);
+}
 }
 }
 }