Normalize obligations before matching them against a candidate

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -2512,7 +2512,20 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
 
         debug!(?impl_trait_ref);
 
-        let Normalized { value: impl_trait_ref, obligations: mut nested_obligations } =
+        let Normalized {
+            value: placeholder_obligation_trait_ref,
+            obligations: mut nested_obligations,
+        } = ensure_sufficient_stack(|| {
+            project::normalize_with_depth(
+                self,
+                obligation.param_env,
+                obligation.cause.clone(),
+                obligation.recursion_depth + 1,
+                placeholder_obligation_trait_ref,
+            )
+        });
+
+        let Normalized { value: impl_trait_ref, obligations: more_nested_obligations } =
             ensure_sufficient_stack(|| {
                 project::normalize_with_depth(
                     self,
@@ -2522,6 +2535,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                     impl_trait_ref,
                 )
             });
+        nested_obligations.extend(more_nested_obligations);
 
         debug!(?impl_trait_ref, ?placeholder_obligation_trait_ref);
 

tests/ui/associated-types/hr-associated-type-bound-object.stderr

@@ -12,6 +12,10 @@ LL | trait X<'a>
 LL | where
 LL |     for<'b> <Self as X<'b>>::U: Clone,
    |                                 ^^^^^ required by this bound in `X`
+help: consider further restricting the associated type
+   |
+LL | fn f<'a, T: X<'a> + ?Sized>(x: &<T as X<'a>>::U) where for<'b> <T as X<'b>>::U: Clone {
+   |                                                  ++++++++++++++++++++++++++++++++++++
 
 error: aborting due to previous error
 

tests/ui/generic-associated-types/bugs/issue-88460.rs

@@ -1,7 +1,6 @@
-// check-fail
-// known-bug: #88460
+// check-pass
 
-// This should pass, but has a missed normalization due to HRTB.
+// Used to fail due to a missed normalization due to HRTB.
 
 pub trait Marker {}
 

tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90950.rs

@@ -1,18 +1,15 @@
-// check-fail
-// known-bug: #90950
+// check-pass
 
 trait Yokeable<'a>: 'static {
     type Output: 'a;
 }
 
-
 trait IsCovariant<'a> {}
 
 struct Yoke<Y: for<'a> Yokeable<'a>> {
     data: Y,
 }
 
-
 // impl<Y: for<'a> Yokeable<'a>> Yoke<Y> {
 //     fn project<Y2: for<'a> Yokeable<'a>>(
 //         &self,
@@ -22,17 +19,17 @@ struct Yoke<Y: for<'a> Yokeable<'a>> {
 //     }
 // }
 
-fn upcast<Y>(x: Yoke<Y>) -> Yoke<Box<dyn IsCovariant<'static> + 'static>> where
+fn upcast<Y>(x: Yoke<Y>) -> Yoke<Box<dyn IsCovariant<'static> + 'static>>
+where
     Y: for<'a> Yokeable<'a>,
-    for<'a> <Y as Yokeable<'a>>::Output: IsCovariant<'a>
-    {
+    for<'a> <Y as Yokeable<'a>>::Output: IsCovariant<'a>,
+{
     // x.project(|data, _| {
     //     Box::new(data)
     // })
     unimplemented!()
 }
 
-
 impl<'a> Yokeable<'a> for Box<dyn IsCovariant<'static> + 'static> {
     type Output = Box<dyn IsCovariant<'a> + 'a>;
 }
@@ -44,8 +41,6 @@ impl<'a, T: ToOwned + ?Sized> Yokeable<'a> for Cow<'static, T> {
 }
 impl<'a, T: ToOwned + ?Sized> IsCovariant<'a> for Cow<'a, T> {}
 
-
-
 fn upcast_yoke(y: Yoke<Cow<'static, str>>) -> Yoke<Box<dyn IsCovariant<'static> + 'static>> {
     upcast(y)
 }

tests/ui/higher-rank-trait-bounds/normalize-under-binder/norm-before-method-resolution.rs

@@ -1,7 +1,6 @@
-// check-fail
-// known-bug: #89196
+// check-pass
 
-// Should pass, but we normalize and check bounds before we resolve the generics
+// We normalize and check bounds before we resolve the generics
 // of the function (which we know because of the return type).
 
 trait Trait<'a> {
@@ -13,10 +12,12 @@ impl<'a, T> Trait<'a> for T {
 }
 
 fn weird_bound<X>() -> X
-    where
-        for<'a> X: Trait<'a>,
-        for<'a> <X as Trait<'a>>::Out: Copy
-{ todo!() }
+where
+    for<'a> X: Trait<'a>,
+    for<'a> <X as Trait<'a>>::Out: Copy,
+{
+    todo!()
+}
 
 fn main() {
     let _: () = weird_bound();