Auto merge of #151746 - jdonszelmann:eagerly-normalize-in-generalize, r=<try>

Eagerly normalize in generalize

Author: bors

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -377,19 +377,20 @@ impl<'b, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'b, 'tcx> {
                 );
             }
 
+            (_, ty::Alias(..)) | (ty::Alias(..), _) if infcx.next_trait_solver() => {
+                self.register_alias_relate_predicate(a, b);
+            }
+
             (&ty::Infer(ty::TyVar(a_vid)), _) => {
                 infcx.instantiate_ty_var(self, true, a_vid, self.ambient_variance, b)?
             }
 
             (
                 &ty::Alias(ty::Opaque, ty::AliasTy { def_id: a_def_id, .. }),
                 &ty::Alias(ty::Opaque, ty::AliasTy { def_id: b_def_id, .. }),
-            ) if a_def_id == b_def_id || infcx.next_trait_solver() => {
+            ) if a_def_id == b_def_id => {
+                debug_assert!(!infcx.next_trait_solver());
                 super_combine_tys(&infcx.infcx, self, a, b).map(|_| ()).or_else(|err| {
-                    // This behavior is only there for the old solver, the new solver
-                    // shouldn't ever fail. Instead, it unconditionally emits an
-                    // alias-relate goal.
-                    assert!(!self.type_checker.infcx.next_trait_solver());
                     self.cx().dcx().span_delayed_bug(
                         self.span(),
                         "failure to relate an opaque to itself should result in an error later on",
@@ -399,7 +400,7 @@ impl<'b, 'tcx> TypeRelation<TyCtxt<'tcx>> for NllTypeRelating<'_, 'b, 'tcx> {
             }
             (&ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }), _)
             | (_, &ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }))
-                if def_id.is_local() && !self.type_checker.infcx.next_trait_solver() =>
+                if def_id.is_local() =>
             {
                 self.relate_opaques(a, b)?;
             }
@@ -616,4 +617,9 @@ impl<'b, 'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for NllTypeRelating<'_
             }
         })]);
     }
+
+    fn try_eagerly_normalize_alias(&mut self, _alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
+        // Past hir typeck, so we don't have to worry about type inference anymore.
+        self.type_checker.infcx.next_ty_var(self.span())
+    }
 }

compiler/rustc_infer/src/infer/at.rs

@@ -140,6 +140,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
                 ty::Contravariant,
                 actual,
                 self.cause.span,
+                &mut |alias| {
+                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
+                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -173,6 +176,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
                 ty::Covariant,
                 actual,
                 self.cause.span,
+                &mut |alias| {
+                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
+                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {
@@ -225,6 +231,9 @@ impl<'a, 'tcx> At<'a, 'tcx> {
                 ty::Invariant,
                 actual,
                 self.cause.span,
+                &mut |alias| {
+                    self.infcx.try_eagerly_normalize_alias(self.param_env, self.cause.span, alias)
+                },
             )
             .map(|goals| self.goals_to_obligations(goals))
         } else {

compiler/rustc_infer/src/infer/mod.rs

@@ -1,5 +1,5 @@
 use std::cell::{Cell, RefCell};
-use std::fmt;
+use std::{fmt, mem};
 
 pub use at::DefineOpaqueTypes;
 use free_regions::RegionRelations;
@@ -21,6 +21,7 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_macros::extension;
 pub use rustc_macros::{TypeFoldable, TypeVisitable};
 use rustc_middle::bug;
+use rustc_middle::hooks::TypeErasedInfcx;
 use rustc_middle::infer::canonical::{CanonicalQueryInput, CanonicalVarValues};
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::select;
@@ -1465,6 +1466,17 @@ impl<'tcx> InferCtxt<'tcx> {
         }
     }
 
+    pub fn try_eagerly_normalize_alias<'a>(
+        &'a self,
+        param_env: ty::ParamEnv<'tcx>,
+        span: Span,
+        alias: ty::AliasTy<'tcx>,
+    ) -> Ty<'tcx> {
+        let erased =
+            unsafe { mem::transmute::<&'a InferCtxt<'tcx>, TypeErasedInfcx<'a, 'tcx>>(self) };
+        self.tcx.try_eagerly_normalize_alias(erased, param_env, span, alias)
+    }
+
     /// Attach a callback to be invoked on each root obligation evaluated in the new trait solver.
     pub fn attach_obligation_inspector(&self, inspector: ObligationInspector<'tcx>) {
         debug_assert!(

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -76,6 +76,7 @@ impl<'tcx> InferCtxt<'tcx> {
             target_vid,
             instantiation_variance,
             source_ty,
+            &mut |alias| relation.try_eagerly_normalize_alias(alias),
         )?;
 
         // Constrain `b_vid` to the generalized type `generalized_ty`.
@@ -210,6 +211,7 @@ impl<'tcx> InferCtxt<'tcx> {
             target_vid,
             ty::Invariant,
             source_ct,
+            &mut |alias| relation.try_eagerly_normalize_alias(alias),
         )?;
 
         debug_assert!(!generalized_ct.is_ct_infer());
@@ -249,6 +251,7 @@ impl<'tcx> InferCtxt<'tcx> {
         target_vid: impl Into<TermVid>,
         ambient_variance: ty::Variance,
         source_term: T,
+        normalize: &mut dyn FnMut(ty::AliasTy<'tcx>) -> Ty<'tcx>,
     ) -> RelateResult<'tcx, Generalization<T>> {
         assert!(!source_term.has_escaping_bound_vars());
         let (for_universe, root_vid) = match target_vid.into() {
@@ -264,15 +267,20 @@ impl<'tcx> InferCtxt<'tcx> {
         let mut generalizer = Generalizer {
             infcx: self,
             span,
-            structurally_relate_aliases,
             root_vid,
             for_universe,
             root_term: source_term.into(),
             ambient_variance,
-            in_alias: false,
+            state: match structurally_relate_aliases {
+                StructurallyRelateAliases::No => GeneralizerState::Default,
+                StructurallyRelateAliases::Yes => GeneralizerState::StructurallyRelateAliases,
+            },
             cache: Default::default(),
+            normalize,
         };
 
+        debug!(?root_vid, ?generalizer.root_term, "generalize");
+
         let value_may_be_infer = generalizer.relate(source_term, source_term)?;
         Ok(Generalization { value_may_be_infer })
     }
@@ -317,6 +325,16 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MaxUniverse {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum GeneralizerState {
+    /// Treat aliases as potentially normalizable.
+    Default,
+    IncompletelyRelateHigherRankedAlias,
+    /// Only one layer
+    ShallowStructurallyRelateAliases,
+    StructurallyRelateAliases,
+}
+
 /// The "generalizer" is used when handling inference variables.
 ///
 /// The basic strategy for handling a constraint like `?A <: B` is to
@@ -335,10 +353,6 @@ struct Generalizer<'me, 'tcx> {
 
     span: Span,
 
-    /// Whether aliases should be related structurally. If not, we have to
-    /// be careful when generalizing aliases.
-    structurally_relate_aliases: StructurallyRelateAliases,
-
     /// The vid of the type variable that is in the process of being
     /// instantiated. If we find this within the value we are folding,
     /// that means we would have created a cyclic value.
@@ -361,9 +375,13 @@ struct Generalizer<'me, 'tcx> {
     /// This is necessary to correctly handle
     /// `<T as Bar<<?0 as Foo>::Assoc>::Assoc == ?0`. This equality can
     /// hold by either normalizing the outer or the inner associated type.
-    in_alias: bool,
+    state: GeneralizerState,
 
-    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, bool), Ty<'tcx>>,
+    cache: SsoHashMap<(Ty<'tcx>, ty::Variance, GeneralizerState), Ty<'tcx>>,
+
+    /// Normalize an alias in the trait solver.
+    /// If normalization fails, a fresh infer var is returned.
+    normalize: &'me mut dyn FnMut(ty::AliasTy<'tcx>) -> Ty<'tcx>,
 }
 
 impl<'tcx> Generalizer<'_, 'tcx> {
@@ -399,27 +417,51 @@ impl<'tcx> Generalizer<'_, 'tcx> {
     ///   continue generalizing the alias. This ends up pulling down the universe of the
     ///   inference variable and is incomplete in case the alias would normalize to a type
     ///   which does not mention that inference variable.
-    fn generalize_alias_ty(
+    fn handle_alias_ty(
         &mut self,
+        alias_ty: Ty<'tcx>,
         alias: ty::AliasTy<'tcx>,
     ) -> Result<Ty<'tcx>, TypeError<'tcx>> {
-        // We do not eagerly replace aliases with inference variables if they have
-        // escaping bound vars, see the method comment for details. However, when we
-        // are inside of an alias with escaping bound vars replacing nested aliases
-        // with inference variables can cause incorrect ambiguity.
-        //
-        // cc trait-system-refactor-initiative#110
-        if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() && !self.in_alias {
-            return Ok(self.next_ty_var_for_alias());
+        match self.state {
+            GeneralizerState::ShallowStructurallyRelateAliases => {
+                // We can switch back to default, we've treated one layer as rigid by doing this operation.
+                self.state = GeneralizerState::Default;
+                let res = relate::structurally_relate_tys(self, alias_ty, alias_ty);
+                self.state = GeneralizerState::ShallowStructurallyRelateAliases;
+                return res;
+            }
+            GeneralizerState::StructurallyRelateAliases => {
+                return relate::structurally_relate_tys(self, alias_ty, alias_ty);
+            }
+            GeneralizerState::Default
+                if self.infcx.next_trait_solver() && !alias.has_escaping_bound_vars() =>
+            {
+                // We do not eagerly replace aliases with inference variables if they have
+                // escaping bound vars, see the method comment for details. However, when we
+                // are inside of an alias with escaping bound vars replacing nested aliases
+                // with inference variables can cause incorrect ambiguity.
+                //
+                // cc trait-system-refactor-initiative#110
+                let normalized_alias = (self.normalize)(alias);
+
+                self.state = GeneralizerState::ShallowStructurallyRelateAliases;
+                // recursively generalize, trCeat the outer alias as rigid to avoid infinite recursion
+                let res = self.relate(normalized_alias, normalized_alias);
+
+                // only one way to get here
+                self.state = GeneralizerState::Default;
+
+                return res;
+            }
+            GeneralizerState::Default | GeneralizerState::IncompletelyRelateHigherRankedAlias => {}
         }
 
-        let is_nested_alias = mem::replace(&mut self.in_alias, true);
+        let previous_state =
+            mem::replace(&mut self.state, GeneralizerState::IncompletelyRelateHigherRankedAlias);
         let result = match self.relate(alias, alias) {
             Ok(alias) => Ok(alias.to_ty(self.cx())),
-            Err(e) => {
-                if is_nested_alias {
-                    return Err(e);
-                } else {
+            Err(e) => match previous_state {
+                GeneralizerState::Default => {
                     let mut visitor = MaxUniverse::new();
                     alias.visit_with(&mut visitor);
                     let infer_replacement_is_complete =
@@ -432,9 +474,14 @@ impl<'tcx> Generalizer<'_, 'tcx> {
                     debug!("generalization failure in alias");
                     Ok(self.next_ty_var_for_alias())
                 }
-            }
+                GeneralizerState::IncompletelyRelateHigherRankedAlias => return Err(e),
+
+                // Early return.
+                GeneralizerState::ShallowStructurallyRelateAliases
+                | GeneralizerState::StructurallyRelateAliases => unreachable!(),
+            },
         };
-        self.in_alias = is_nested_alias;
+        self.state = previous_state;
         result
     }
 }
@@ -488,7 +535,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
     fn tys(&mut self, t: Ty<'tcx>, t2: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
         assert_eq!(t, t2); // we are misusing TypeRelation here; both LHS and RHS ought to be ==
 
-        if let Some(&result) = self.cache.get(&(t, self.ambient_variance, self.in_alias)) {
+        if let Some(&result) = self.cache.get(&(t, self.ambient_variance, self.state)) {
             return Ok(result);
         }
 
@@ -553,9 +600,15 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                             // cc trait-system-refactor-initiative#108
                             if self.infcx.next_trait_solver()
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
-                                && self.in_alias
                             {
-                                inner.type_variables().equate(vid, new_var_id);
+                                match self.state {
+                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                                        inner.type_variables().equate(vid, new_var_id);
+                                    }
+                                    GeneralizerState::Default
+                                    | GeneralizerState::ShallowStructurallyRelateAliases
+                                    | GeneralizerState::StructurallyRelateAliases => {}
+                                }
                             }
 
                             debug!("replacing original vid={:?} with new={:?}", vid, new_var_id);
@@ -584,15 +637,12 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                 }
             }
 
-            ty::Alias(_, data) => match self.structurally_relate_aliases {
-                StructurallyRelateAliases::No => self.generalize_alias_ty(data),
-                StructurallyRelateAliases::Yes => relate::structurally_relate_tys(self, t, t),
-            },
+            ty::Alias(_, data) => self.handle_alias_ty(t, data),
 
             _ => relate::structurally_relate_tys(self, t, t),
         }?;
 
-        self.cache.insert((t, self.ambient_variance, self.in_alias), g);
+        self.cache.insert((t, self.ambient_variance, self.state), g);
         Ok(g)
     }
 
@@ -683,9 +733,15 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
                             // for more details.
                             if self.infcx.next_trait_solver()
                                 && !matches!(self.infcx.typing_mode(), TypingMode::Coherence)
-                                && self.in_alias
                             {
-                                variable_table.union(vid, new_var_id);
+                                match self.state {
+                                    GeneralizerState::IncompletelyRelateHigherRankedAlias => {
+                                        variable_table.union(vid, new_var_id);
+                                    }
+                                    GeneralizerState::Default
+                                    | GeneralizerState::ShallowStructurallyRelateAliases
+                                    | GeneralizerState::StructurallyRelateAliases => {}
+                                }
                             }
                             Ok(ty::Const::new_var(self.cx(), new_var_id))
                         }

compiler/rustc_infer/src/infer/relate/lattice.rs

@@ -299,4 +299,8 @@ impl<'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for LatticeOp<'_, 'tcx> {
             ty::AliasRelationDirection::Equate,
         ))]);
     }
+
+    fn try_eagerly_normalize_alias(&mut self, alias: ty::AliasTy<'tcx>) -> Ty<'tcx> {
+        self.infcx.try_eagerly_normalize_alias(self.param_env(), self.span(), alias)
+    }
 }

compiler/rustc_infer/src/infer/relate/type_relating.rs

@@ -396,4 +396,13 @@ impl<'tcx> PredicateEmittingRelation<InferCtxt<'tcx>> for TypeRelating<'_, 'tcx>
             }
         })]);
     }
+
+    fn try_eagerly_normalize_alias(
+        &mut self,
+        _alias: rustc_type_ir::AliasTy<<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner>,
+    ) -> <<InferCtxt<'tcx> as rustc_type_ir::InferCtxtLike>::Interner as rustc_type_ir::Interner>::Ty
+    {
+        // We only try to eagerly normalize aliases if we're using the new solver.
+        unreachable!()
+    }
 }

compiler/rustc_interface/src/passes.rs

@@ -901,7 +901,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     rustc_hir_typeck::provide(&mut providers.queries);
     ty::provide(&mut providers.queries);
     traits::provide(&mut providers.queries);
-    solve::provide(&mut providers.queries);
+    solve::provide(providers);
     rustc_passes::provide(&mut providers.queries);
     rustc_traits::provide(&mut providers.queries);
     rustc_ty_utils::provide(&mut providers.queries);