Use NormalizesTo instead of AliasRelate for normalization

ShoyuVanilla · ShoyuVanilla · commit f6869530590f · 2026-04-03T01:56:20.000+09:00
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -2292,9 +2292,11 @@ pub(super) fn check_potentially_region_dependent_goals<'tcx>(
     let infcx = tcx.infer_ctxt().ignoring_regions().build(typing_mode);
     let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
     for (predicate, cause) in &typeck_results.potentially_region_dependent_goals {
+        tracing::debug!("PREDA {predicate:?}");
         let predicate = fold_regions(tcx, *predicate, |_, _| {
             infcx.next_region_var(RegionVariableOrigin::Misc(cause.span))
         });
+        tracing::debug!("PREDB {predicate:?}");
         ocx.register_obligation(Obligation::new(tcx, cause.clone(), param_env, predicate));
     }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -1219,13 +1219,12 @@ where
 
     fn fold_ty(&mut self, ty: Ty<I>) -> Ty<I> {
         match ty.kind() {
-            ty::Alias(..) if !ty.has_escaping_bound_vars() => {
+            ty::Alias(_, alias) if !ty.has_escaping_bound_vars() => {
                 let infer_ty = self.ecx.next_ty_infer();
-                let normalizes_to = ty::PredicateKind::AliasRelate(
-                    ty.into(),
-                    infer_ty.into(),
-                    ty::AliasRelationDirection::Equate,
-                );
+                let normalizes_to = ty::PredicateKind::NormalizesTo(ty::NormalizesTo {
+                    alias: ty::AliasTerm::new_from_args(self.cx(), alias.def_id, alias.args),
+                    term: infer_ty.into(),
+                });
                 self.ecx.add_goal(
                     self.normalization_goal_source,
                     Goal::new(self.cx(), self.param_env, normalizes_to),
@@ -1248,13 +1247,12 @@ where
 
     fn fold_const(&mut self, ct: I::Const) -> I::Const {
         match ct.kind() {
-            ty::ConstKind::Unevaluated(..) if !ct.has_escaping_bound_vars() => {
+            ty::ConstKind::Unevaluated(uc) if !ct.has_escaping_bound_vars() => {
                 let infer_ct = self.ecx.next_const_infer();
-                let normalizes_to = ty::PredicateKind::AliasRelate(
-                    ct.into(),
-                    infer_ct.into(),
-                    ty::AliasRelationDirection::Equate,
-                );
+                let normalizes_to = ty::PredicateKind::NormalizesTo(ty::NormalizesTo {
+                    alias: ty::AliasTerm::new_from_args(self.cx(), uc.def.into(), uc.args),
+                    term: infer_ct.into(),
+                });
                 self.ecx.add_goal(
                     self.normalization_goal_source,
                     Goal::new(self.cx(), self.param_env, normalizes_to),
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -344,20 +344,16 @@ where
         param_env: I::ParamEnv,
         term: I::Term,
     ) -> Result<I::Term, NoSolution> {
-        if let Some(_) = term.to_alias_term() {
+        if let Some(alias) = term.to_alias_term() {
             let normalized_term = self.next_term_infer_of_kind(term);
-            let alias_relate_goal = Goal::new(
+            let normalizes_to_goal = Goal::new(
                 self.cx(),
                 param_env,
-                ty::PredicateKind::AliasRelate(
-                    term,
-                    normalized_term,
-                    ty::AliasRelationDirection::Equate,
-                ),
+                ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term: normalized_term }),
             );
             // We normalize the self type to be able to relate it with
             // types from candidates.
-            self.add_goal(GoalSource::TypeRelating, alias_relate_goal);
+            self.add_goal(GoalSource::TypeRelating, normalizes_to_goal);
             self.try_evaluate_added_goals()?;
             Ok(self.resolve_vars_if_possible(normalized_term))
         } else {
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs
@@ -32,7 +32,7 @@ where
                 goal.predicate.alias.args,
             ),
         ) {
-            self.instantiate_normalizes_to_term(goal, normalized_const.into());
+            self.eq(goal.param_env, goal.predicate.term, normalized_const.into())?;
             self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         } else {
             self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/free_alias.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/free_alias.rs
@@ -35,7 +35,7 @@ where
             cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args).into()
         };
 
-        self.instantiate_normalizes_to_term(goal, actual);
+        self.eq(goal.param_env, goal.predicate.term, actual)?;
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs
@@ -56,7 +56,7 @@ where
         } else {
             cx.const_of_item(inherent.def_id).instantiate(cx, inherent_args).into()
         };
-        self.instantiate_normalizes_to_term(goal, normalized);
+        self.eq(goal.param_env, goal.predicate.term, normalized)?;
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -113,18 +113,14 @@ where
     /// We know `term` to always be a fully unconstrained inference variable, so
     /// `eq` should never fail here. However, in case `term` contains aliases, we
     /// emit nested `AliasRelate` goals to structurally normalize the alias.
-    pub fn instantiate_normalizes_to_term(
-        &mut self,
-        goal: Goal<I, NormalizesTo<I>>,
-        term: I::Term,
-    ) {
+    fn instantiate_normalizes_to_term(&mut self, goal: Goal<I, NormalizesTo<I>>, term: I::Term) {
         self.eq(goal.param_env, goal.predicate.term, term)
             .expect("expected goal term to be fully unconstrained");
     }
 
     /// Unlike `instantiate_normalizes_to_term` this instantiates the expected term
     /// with a rigid alias. Using this is pretty much always wrong.
-    pub fn structurally_instantiate_normalizes_to_term(
+    fn structurally_instantiate_normalizes_to_term(
         &mut self,
         goal: Goal<I, NormalizesTo<I>>,
         term: ty::AliasTerm<I>,
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs
@@ -48,7 +48,12 @@ where
                     .filter(|&def_id| defining_opaque_types.contains(&def_id))
                 else {
                     // If we're not in the defining scope, treat the alias as rigid.
-                    self.structurally_instantiate_normalizes_to_term(goal, goal.predicate.alias);
+                    self.relate_rigid_alias_non_alias(
+                        goal.param_env,
+                        goal.predicate.alias,
+                        ty::Invariant,
+                        goal.predicate.term,
+                    )?;
                     return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
                 };
 
@@ -111,7 +116,12 @@ where
                     .as_local()
                     .filter(|&def_id| defined_opaque_types.contains(&def_id))
                 else {
-                    self.structurally_instantiate_normalizes_to_term(goal, goal.predicate.alias);
+                    self.relate_rigid_alias_non_alias(
+                        goal.param_env,
+                        goal.predicate.alias,
+                        ty::Invariant,
+                        goal.predicate.term,
+                    )?;
                     return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
                 };
 
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -185,6 +185,7 @@ where
         loop {
             let mut any_changed = false;
             for (mut obligation, stalled_on) in self.obligations.drain_pending(|_| true) {
+                let orig = obligation.clone();
                 if !infcx.tcx.recursion_limit().value_within_limit(obligation.recursion_depth) {
                     self.obligations.on_fulfillment_overflow(infcx);
                     // Only return true errors that we have accumulated while processing.
@@ -255,6 +256,7 @@ where
                         if infcx.in_hir_typeck
                             && (obligation.has_non_region_infer() || obligation.has_free_regions())
                         {
+                            tracing::debug!("REGISTERED {orig:?} - {obligation:?}");
                             infcx.push_hir_typeck_potentially_region_dependent_goal(obligation);
                         }
                     }
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs b/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
@@ -292,13 +292,13 @@ impl<'tcx> BestObligation<'tcx> {
     ) -> ControlFlow<PredicateObligation<'tcx>> {
         assert!(!self.consider_ambiguities);
         let tcx = goal.infcx().tcx;
-        if let ty::Alias(..) = self_ty.kind() {
+        let term: ty::Term<'tcx> = self_ty.into();
+        if let Some(alias) = term.to_alias_term() {
             let infer_term = goal.infcx().next_ty_var(self.obligation.cause.span);
-            let pred = ty::PredicateKind::AliasRelate(
-                self_ty.into(),
-                infer_term.into(),
-                ty::AliasRelationDirection::Equate,
-            );
+            let pred = ty::PredicateKind::NormalizesTo(ty::NormalizesTo {
+                alias,
+                term: infer_term.into(),
+            });
             let obligation =
                 Obligation::new(tcx, self.obligation.cause.clone(), goal.goal().param_env, pred);
             self.with_derived_obligation(obligation, |this| {
diff --git a/compiler/rustc_trait_selection/src/solve/normalize.rs b/compiler/rustc_trait_selection/src/solve/normalize.rs
@@ -102,11 +102,10 @@ where
         let infcx = self.at.infcx;
         let tcx = infcx.tcx;
         let recursion_limit = tcx.recursion_limit();
+        let alias = alias_term.to_alias_term().unwrap();
         if !recursion_limit.value_within_limit(self.depth) {
-            let term = alias_term.to_alias_term().unwrap();
-
             self.at.infcx.err_ctxt().report_overflow_error(
-                OverflowCause::DeeplyNormalize(term),
+                OverflowCause::DeeplyNormalize(alias),
                 self.at.cause.span,
                 true,
                 |_| {},
@@ -120,11 +119,7 @@ where
             tcx,
             self.at.cause.clone(),
             self.at.param_env,
-            ty::PredicateKind::AliasRelate(
-                alias_term.into(),
-                infer_term.into(),
-                ty::AliasRelationDirection::Equate,
-            ),
+            ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term: infer_term }),
         );
 
         self.fulfill_cx.register_predicate_obligation(infcx, obligation);
diff --git a/compiler/rustc_trait_selection/src/traits/structural_normalize.rs b/compiler/rustc_trait_selection/src/traits/structural_normalize.rs
@@ -35,9 +35,9 @@ impl<'tcx> At<'_, 'tcx> {
         assert!(!term.is_infer(), "should have resolved vars before calling");
 
         if self.infcx.next_trait_solver() {
-            if let None = term.to_alias_term() {
+            let Some(alias) = term.to_alias_term() else {
                 return Ok(term);
-            }
+            };
 
             let new_infer = self.infcx.next_term_var_of_kind(term, self.cause.span);
 
@@ -48,7 +48,7 @@ impl<'tcx> At<'_, 'tcx> {
                 self.infcx.tcx,
                 self.cause.clone(),
                 self.param_env,
-                ty::PredicateKind::AliasRelate(term, new_infer, ty::AliasRelationDirection::Equate),
+                ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term: new_infer }),
             );
 
             fulfill_cx.register_predicate_obligation(self.infcx, obligation);
diff --git a/tests/ui/const-generics/mgca/free-const-recursive.rs b/tests/ui/const-generics/mgca/free-const-recursive.rs
@@ -5,7 +5,7 @@
 #![expect(incomplete_features)]
 
 type const A: () = A;
-//~^ ERROR type mismatch resolving `A normalizes-to _`
+//~^ ERROR type mismatch resolving `_ == A`
 //~| ERROR the constant `A` is not of type `()`
 
 fn main() {
diff --git a/tests/ui/const-generics/mgca/free-const-recursive.stderr b/tests/ui/const-generics/mgca/free-const-recursive.stderr
@@ -1,4 +1,4 @@
-error[E0271]: type mismatch resolving `A normalizes-to _`
+error[E0271]: type mismatch resolving `_ == A`
   --> $DIR/free-const-recursive.rs:7:1
    |
 LL | type const A: () = A;
diff --git a/tests/ui/impl-trait/ice-unexpected-param-type-whensubstituting-in-region-112823.next.stderr b/tests/ui/impl-trait/ice-unexpected-param-type-whensubstituting-in-region-112823.next.stderr
@@ -31,19 +31,13 @@ error[E0271]: type mismatch resolving `<Y as X>::LineStreamFut<'a, Repr> == ()`
 LL |     fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {}
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ
 
-error[E0271]: type mismatch resolving `<Y as X>::LineStreamFut<'a, Repr> normalizes-to _`
-  --> $DIR/ice-unexpected-param-type-whensubstituting-in-region-112823.rs:29:73
-   |
-LL |     fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {}
-   |                                                                         ^^ types differ
-
 error[E0271]: type mismatch resolving `<Y as X>::LineStreamFut<'a, Repr> normalizes-to _`
   --> $DIR/ice-unexpected-param-type-whensubstituting-in-region-112823.rs:29:5
    |
 LL |     fn line_stream<'a, Repr>(&'a self) -> Self::LineStreamFut<'a, Repr> {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ
 
-error: aborting due to 6 previous errors
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0049, E0271, E0407.
 For more information about an error, try `rustc --explain E0049`.
diff --git a/tests/ui/impl-trait/ice-unexpected-param-type-whensubstituting-in-region-112823.rs b/tests/ui/impl-trait/ice-unexpected-param-type-whensubstituting-in-region-112823.rs
@@ -31,7 +31,6 @@ impl X for Y {
     //[current]~^^ ERROR `()` is not a future
     //[next]~^^^ ERROR type mismatch resolving `<Y as X>::LineStreamFut<'a, Repr> == ()`
     //[next]~| ERROR type mismatch resolving `<Y as X>::LineStreamFut<'a, Repr> normalizes-to _`
-    //[next]~| ERROR type mismatch resolving `<Y as X>::LineStreamFut<'a, Repr> normalizes-to _`
 }
 
 pub fn main() {}
diff --git a/tests/ui/lazy-type-alias/inherent-impls-overflow.next.stderr b/tests/ui/lazy-type-alias/inherent-impls-overflow.next.stderr
@@ -1,22 +1,22 @@
-error[E0271]: type mismatch resolving `Loop normalizes-to _`
+error[E0271]: type mismatch resolving `_ == Loop`
   --> $DIR/inherent-impls-overflow.rs:8:1
    |
 LL | type Loop = Loop;
    | ^^^^^^^^^ types differ
 
-error[E0271]: type mismatch resolving `Loop normalizes-to _`
+error[E0271]: type mismatch resolving `_ == Loop`
   --> $DIR/inherent-impls-overflow.rs:12:1
    |
 LL | impl Loop {}
    | ^^^^^^^^^^^^ types differ
 
-error[E0271]: type mismatch resolving `Loop normalizes-to _`
+error[E0271]: type mismatch resolving `_ == Loop`
   --> $DIR/inherent-impls-overflow.rs:12:6
    |
 LL | impl Loop {}
    |      ^^^^ types differ
 
-error[E0275]: overflow evaluating the requirement `Poly1<(T,)> == _`
+error[E0275]: overflow evaluating the requirement `Poly1<(T,)> normalizes-to _`
   --> $DIR/inherent-impls-overflow.rs:17:1
    |
 LL | type Poly0<T> = Poly1<(T,)>;
@@ -35,7 +35,7 @@ LL | type Poly0<T> = Poly1<(T,)>;
    = help: consider removing `T` or referring to it in the body of the type alias
    = note: all type parameters must be used in a non-recursive way in order to constrain their variance
 
-error[E0275]: overflow evaluating the requirement `Poly0<(T,)> == _`
+error[E0275]: overflow evaluating the requirement `Poly0<(T,)> normalizes-to _`
   --> $DIR/inherent-impls-overflow.rs:21:1
    |
 LL | type Poly1<T> = Poly0<(T,)>;
@@ -54,15 +54,15 @@ LL | type Poly1<T> = Poly0<(T,)>;
    = help: consider removing `T` or referring to it in the body of the type alias
    = note: all type parameters must be used in a non-recursive way in order to constrain their variance
 
-error[E0275]: overflow evaluating the requirement `Poly0<()> == _`
+error[E0275]: overflow evaluating the requirement `Poly0<()> normalizes-to _`
   --> $DIR/inherent-impls-overflow.rs:26:1
    |
 LL | impl Poly0<()> {}
    | ^^^^^^^^^^^^^^^^^
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`inherent_impls_overflow`)
 
-error[E0275]: overflow evaluating the requirement `Poly0<()> == _`
+error[E0275]: overflow evaluating the requirement `Poly0<()> normalizes-to _`
   --> $DIR/inherent-impls-overflow.rs:26:6
    |
 LL | impl Poly0<()> {}
diff --git a/tests/ui/lazy-type-alias/inherent-impls-overflow.rs b/tests/ui/lazy-type-alias/inherent-impls-overflow.rs
@@ -7,12 +7,12 @@
 
 type Loop = Loop;
 //[current]~^ ERROR overflow normalizing the type alias `Loop`
-//[next]~^^ ERROR type mismatch resolving `Loop normalizes-to _`
+//[next]~^^ ERROR type mismatch resolving `_ == Loop`
 
 impl Loop {}
 //[current]~^ ERROR overflow normalizing the type alias `Loop`
-//[next]~^^ ERROR type mismatch resolving `Loop normalizes-to _`
-//[next]~| ERROR type mismatch resolving `Loop normalizes-to _`
+//[next]~^^ ERROR type mismatch resolving `_ == Loop`
+//[next]~| ERROR type mismatch resolving `_ == Loop`
 
 type Poly0<T> = Poly1<(T,)>;
 //[current]~^ ERROR overflow normalizing the type alias `Poly0<(((((((...,),),),),),),)>`
@@ -25,7 +25,7 @@ type Poly1<T> = Poly0<(T,)>;
 
 impl Poly0<()> {}
 //[current]~^ ERROR overflow normalizing the type alias `Poly1<(((((((...,),),),),),),)>`
-//[next]~^^ ERROR overflow evaluating the requirement `Poly0<()> == _`
+//[next]~^^ ERROR overflow evaluating the requirement `Poly0<()> normalizes-to _`
 //[next]~| ERROR overflow evaluating the requirement
 
 fn main() {}
diff --git a/tests/ui/traits/next-solver/alias-bound-unsound.rs b/tests/ui/traits/next-solver/alias-bound-unsound.rs
@@ -29,8 +29,8 @@ fn main() {
     //~^ ERROR overflow evaluating whether `<() as Foo>::Item` is well-formed
     //~| ERROR overflow evaluating whether `&<() as Foo>::Item` is well-formed
     //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == String`
-    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
-    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
-    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
+    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item normalizes-to _`
+    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item normalizes-to _`
+    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item normalizes-to _`
     println!("{x}");
 }
diff --git a/tests/ui/traits/next-solver/alias-bound-unsound.stderr b/tests/ui/traits/next-solver/alias-bound-unsound.stderr
@@ -18,13 +18,13 @@ error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == String`
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
    |                                           ^^
 
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
+error[E0275]: overflow evaluating the requirement `<() as Foo>::Item normalizes-to _`
   --> $DIR/alias-bound-unsound.rs:28:22
    |
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
+error[E0275]: overflow evaluating the requirement `<() as Foo>::Item normalizes-to _`
   --> $DIR/alias-bound-unsound.rs:28:22
    |
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
@@ -44,7 +44,7 @@ error[E0275]: overflow evaluating whether `<() as Foo>::Item` is well-formed
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
+error[E0275]: overflow evaluating the requirement `<() as Foo>::Item normalizes-to _`
   --> $DIR/alias-bound-unsound.rs:28:22
    |
 LL |     let _ = identity(<() as Foo>::copy_me(&x));
diff --git a/tests/ui/traits/next-solver/assembly/ambiguity-due-to-uniquification-2.next.stderr b/tests/ui/traits/next-solver/assembly/ambiguity-due-to-uniquification-2.next.stderr
diff --git a/tests/ui/traits/next-solver/assembly/ambiguity-due-to-uniquification-2.rs b/tests/ui/traits/next-solver/assembly/ambiguity-due-to-uniquification-2.rs
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs
diff --git a/tests/ui/traits/next-solver/normalize/normalize-param-env-2.stderr b/tests/ui/traits/next-solver/normalize/normalize-param-env-2.stderr
diff --git a/tests/ui/traits/next-solver/stalled-coroutine-obligations.stderr b/tests/ui/traits/next-solver/stalled-coroutine-obligations.stderr
diff --git a/tests/ui/traits/unconstrained-projection-normalization-2.next.stderr b/tests/ui/traits/unconstrained-projection-normalization-2.next.stderr
diff --git a/tests/ui/traits/unconstrained-projection-normalization-2.rs b/tests/ui/traits/unconstrained-projection-normalization-2.rs

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ where`
`35`	`35`	`cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args).into()`
`36`	`36`	`};`
`37`	`37`
`38`		`- self.instantiate_normalizes_to_term(goal, actual);`
	`38`	`+ self.eq(goal.param_env, goal.predicate.term, actual)?;`
`39`	`39`	`self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)`
`40`	`40`	`}`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ where`
`56`	`56`	`} else {`
`57`	`57`	`cx.const_of_item(inherent.def_id).instantiate(cx, inherent_args).into()`
`58`	`58`	`};`
`59`		`- self.instantiate_normalizes_to_term(goal, normalized);`
	`59`	`+ self.eq(goal.param_env, goal.predicate.term, normalized)?;`
`60`	`60`	`self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)`
`61`	`61`	`}`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -185,6 +185,7 @@ where`
`185`	`185`	`loop {`
`186`	`186`	`let mut any_changed = false;`
`187`	`187`	`for (mut obligation, stalled_on) in self.obligations.drain_pending(\|_\| true) {`
	`188`	`+ let orig = obligation.clone();`
`188`	`189`	`if !infcx.tcx.recursion_limit().value_within_limit(obligation.recursion_depth) {`
`189`	`190`	`self.obligations.on_fulfillment_overflow(infcx);`
`190`	`191`	`// Only return true errors that we have accumulated while processing.`
`@@ -255,6 +256,7 @@ where`
`255`	`256`	`if infcx.in_hir_typeck`
`256`	`257`	`&& (obligation.has_non_region_infer() \|\| obligation.has_free_regions())`
`257`	`258`	`{`
	`259`	`+ tracing::debug!("REGISTERED {orig:?} - {obligation:?}");`
`258`	`260`	`infcx.push_hir_typeck_potentially_region_dependent_goal(obligation);`
`259`	`261`	`}`
`260`	`262`	`}`