Fix tests and bootstrap

Author: matthewjasper

compiler/rustc_trait_selection/src/opaque_types.rs

@@ -1170,8 +1170,7 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> {
             // This also instantiates nested instances of `impl Trait`.
             let predicate = self.instantiate_opaque_types_in_map(&predicate);
 
-            let cause =
-                traits::ObligationCause::new(span, self.body_id, traits::MiscObligation);
+            let cause = traits::ObligationCause::new(span, self.body_id, traits::MiscObligation);
 
             // Require that the predicate holds for the concrete type.
             debug!("instantiate_opaque_types: predicate={:?}", predicate);

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -241,18 +241,27 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
         traits::ObligationCause::new(self.span, self.body_id, code)
     }
 
-    fn normalize(&mut self) -> Vec<traits::PredicateObligation<'tcx>> {
+    fn normalize(mut self) -> Vec<traits::PredicateObligation<'tcx>> {
         let cause = self.cause(traits::MiscObligation);
         let infcx = &mut self.infcx;
         let param_env = self.param_env;
         let mut obligations = Vec::with_capacity(self.out.len());
-        for pred in &self.out {
-            assert!(!pred.has_escaping_bound_vars());
+        for mut obligation in self.out {
+            assert!(!obligation.has_escaping_bound_vars());
             let mut selcx = traits::SelectionContext::new(infcx);
             let i = obligations.len();
-            let value =
-                traits::normalize_to(&mut selcx, param_env, cause.clone(), pred, &mut obligations);
-            obligations.insert(i, value);
+            // Don't normalize the whole obligation, the param env is either
+            // already normalized, or we're currently normalizing the
+            // param_env. Either way we should only normalize the predicate.
+            let normalized_predicate = traits::normalize_to(
+                &mut selcx,
+                param_env,
+                cause.clone(),
+                &obligation.predicate,
+                &mut obligations,
+            );
+            obligation.predicate = normalized_predicate;
+            obligations.insert(i, obligation);
         }
         obligations
     }

compiler/rustc_typeck/src/check/compare_method.rs

@@ -1256,6 +1256,7 @@ pub fn check_type_bounds<'tcx>(
             );
             debug!("compare_projection_bounds: normalized predicate = {:?}", normalized_predicate);
 
+            inh.register_predicates(obligations);
             inh.register_predicate(obligation);
         }
 

compiler/rustc_typeck/src/collect.rs

@@ -1787,10 +1787,22 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat
                 }) => {
                     if impl_trait_fn.is_some() {
                         // return-position impl trait
-                        // TODO: Investigate why we have this special case?
+                        //
+                        // We don't inherit predicates from the parent here:
+                        // If we have, say `fn f<'a, T: 'a>() -> impl Sized {}`
+                        // then the return type is `f::<'static, T>::{{opaque}}`.
+                        //
+                        // If we inherited the predicates of `f` then we would
+                        // require that `T: 'static` to show that the return
+                        // type is well-formed.
+                        //
+                        // The only way to have something with this opaque type
+                        // is from the return type of the containing function,
+                        // which will ensure that the function's predicates
+                        // hold.
                         return ty::GenericPredicates { parent: None, predicates: &[] };
                     } else {
-                        // type alias impl trait
+                        // type-alias impl trait
                         generics
                     }
                 }

src/test/incremental/issue-54242.rs

@@ -1,6 +1,6 @@
 // revisions: rpass cfail
 
-trait Tr {
+trait Tr where Self::Arr: Sized {
     type Arr;
 
     const C: usize = 0;

src/test/mir-opt/simplify_arm.id_try.SimplifyArmIdentity.diff

@@ -1,6 +1,6 @@
 - // MIR for `id_try` before SimplifyArmIdentity
 + // MIR for `id_try` after SimplifyArmIdentity
-  
+
   fn id_try(_1: std::result::Result<u8, i32>) -> std::result::Result<u8, i32> {
       debug r => _1;                       // in scope 0 at $DIR/simplify-arm.rs:23:11: 23:12
       let mut _0: std::result::Result<u8, i32>; // return place in scope 0 at $DIR/simplify-arm.rs:23:34: 23:49
@@ -42,7 +42,7 @@
       scope 6 {
           debug self => _4;                // in scope 6 at $SRC_DIR/core/src/result.rs:LL:COL
       }
-  
+
       bb0: {
           StorageLive(_2);                 // scope 0 at $DIR/simplify-arm.rs:24:9: 24:10
           StorageLive(_3);                 // scope 0 at $DIR/simplify-arm.rs:24:13: 24:15
@@ -53,7 +53,7 @@
           _5 = discriminant(_3);           // scope 0 at $DIR/simplify-arm.rs:24:14: 24:15
           switchInt(move _5) -> [0_isize: bb1, 1_isize: bb3, otherwise: bb2]; // scope 0 at $DIR/simplify-arm.rs:24:14: 24:15
       }
-  
+
       bb1: {
 -         StorageLive(_10);                // scope 0 at $DIR/simplify-arm.rs:24:13: 24:15
 -         _10 = ((_3 as Ok).0: u8);        // scope 0 at $DIR/simplify-arm.rs:24:13: 24:15
@@ -69,11 +69,11 @@
           StorageDead(_2);                 // scope 0 at $DIR/simplify-arm.rs:26:1: 26:2
           goto -> bb4;                     // scope 0 at $DIR/simplify-arm.rs:26:2: 26:2
       }
-  
+
       bb2: {
           unreachable;                     // scope 0 at $DIR/simplify-arm.rs:24:13: 24:15
       }
-  
+
       bb3: {
 -         StorageLive(_6);                 // scope 0 at $DIR/simplify-arm.rs:24:14: 24:15
 -         _6 = ((_3 as Err).0: i32);       // scope 0 at $DIR/simplify-arm.rs:24:14: 24:15
@@ -94,9 +94,9 @@
           StorageDead(_2);                 // scope 0 at $DIR/simplify-arm.rs:26:1: 26:2
           goto -> bb4;                     // scope 0 at $DIR/simplify-arm.rs:26:2: 26:2
       }
-  
+
       bb4: {
           return;                          // scope 0 at $DIR/simplify-arm.rs:26:2: 26:2
       }
   }
-  
+

src/test/mir-opt/simplify_arm.id_try.SimplifyBranchSame.diff

@@ -1,6 +1,6 @@
 - // MIR for `id_try` before SimplifyBranchSame
 + // MIR for `id_try` after SimplifyBranchSame
-  
+
   fn id_try(_1: std::result::Result<u8, i32>) -> std::result::Result<u8, i32> {
       debug r => _1;                       // in scope 0 at $DIR/simplify-arm.rs:23:11: 23:12
       let mut _0: std::result::Result<u8, i32>; // return place in scope 0 at $DIR/simplify-arm.rs:23:34: 23:49
@@ -37,7 +37,7 @@
       scope 6 {
           debug self => _4;                // in scope 6 at $SRC_DIR/core/src/result.rs:LL:COL
       }
-  
+
       bb0: {
           StorageLive(_2);                 // scope 0 at $DIR/simplify-arm.rs:24:9: 24:10
           StorageLive(_3);                 // scope 0 at $DIR/simplify-arm.rs:24:13: 24:15
@@ -49,28 +49,28 @@
 -         switchInt(move _5) -> [0_isize: bb1, 1_isize: bb3, otherwise: bb2]; // scope 0 at $DIR/simplify-arm.rs:24:14: 24:15
 +         goto -> bb1;                     // scope 0 at $DIR/simplify-arm.rs:24:14: 24:15
       }
-  
+
       bb1: {
           _0 = move _3;                    // scope 1 at $DIR/simplify-arm.rs:25:5: 25:10
           StorageDead(_3);                 // scope 0 at $DIR/simplify-arm.rs:24:15: 24:16
           StorageDead(_2);                 // scope 0 at $DIR/simplify-arm.rs:26:1: 26:2
 -         goto -> bb4;                     // scope 0 at $DIR/simplify-arm.rs:26:2: 26:2
 +         goto -> bb2;                     // scope 0 at $DIR/simplify-arm.rs:26:2: 26:2
       }
-  
+
       bb2: {
 -         unreachable;                     // scope 0 at $DIR/simplify-arm.rs:24:13: 24:15
 -     }
-- 
+-
 -     bb3: {
 -         _0 = move _3;                    // scope 8 at $SRC_DIR/core/src/result.rs:LL:COL
 -         StorageDead(_3);                 // scope 0 at $DIR/simplify-arm.rs:24:15: 24:16
 -         StorageDead(_2);                 // scope 0 at $DIR/simplify-arm.rs:26:1: 26:2
 -         goto -> bb4;                     // scope 0 at $DIR/simplify-arm.rs:26:2: 26:2
 -     }
-- 
+-
 -     bb4: {
           return;                          // scope 0 at $DIR/simplify-arm.rs:26:2: 26:2
       }
   }
-  
+

src/test/mir-opt/simplify_try.try_identity.DestinationPropagation.diff

@@ -25,7 +25,7 @@
               }
               scope 8 {
                   debug v => ((_0 as Err).0: i32); // in scope 8 at $SRC_DIR/core/src/result.rs:LL:COL
-                  let mut _12: i32;        // in scope 8 at $DIR/simplify_try.rs:8:14: 8:15
+                  let mut _12: i32;        // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15
               }
           }
       }

src/test/mir-opt/simplify_try.try_identity.SimplifyArmIdentity.diff

@@ -29,7 +29,7 @@
               scope 8 {
 -                 debug v => _8;           // in scope 8 at $SRC_DIR/core/src/result.rs:LL:COL
 +                 debug v => ((_0 as Err).0: i32); // in scope 8 at $SRC_DIR/core/src/result.rs:LL:COL
-                  let mut _12: i32;        // in scope 8 at $DIR/simplify_try.rs:8:14: 8:15
+                  let mut _12: i32;        // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15
               }
           }
       }

src/test/mir-opt/simplify_try.try_identity.SimplifyBranchSame.after.mir

@@ -24,7 +24,7 @@ fn try_identity(_1: std::result::Result<u32, i32>) -> std::result::Result<u32, i
             }
             scope 8 {
                 debug v => ((_0 as Err).0: i32); // in scope 8 at $SRC_DIR/core/src/result.rs:LL:COL
-                let mut _12: i32;        // in scope 8 at $DIR/simplify_try.rs:8:14: 8:15
+                let mut _12: i32;        // in scope 8 at $DIR/simplify_try.rs:8:13: 8:15
             }
         }
     }

src/test/ui/associated-types/param-env-normalize-cycle.rs

@@ -0,0 +1,39 @@
+// Minimized case from typenum that didn't compile because:
+// - We tried to normalize the ParamEnv of the second impl
+// - This requires trying to normalize `GrEq<Self, Square<Square<U>>>`
+// - This requires proving `Square<Square<U>>: Sized` so that the first impl
+//   applies
+// - This requires Providing `Square<Square<U>>` is well-formed, so that we
+//   can use the `Sized` bound on `Mul::Output`
+// - This requires proving `Square<U>: Mul`
+// - But first we tried normalizing the whole obligation, including the
+//   ParamEnv, which leads to a cycle error.
+
+// check-pass
+
+trait PrivateSquareRoot {}
+
+pub trait Mul<Rhs = Self> {
+    type Output;
+}
+
+pub trait IsGreaterOrEqual<Rhs> {
+    type Output;
+}
+
+pub type Square<A> = <A as Mul>::Output;
+pub type GrEq<A, B> = <A as IsGreaterOrEqual<B>>::Output;
+
+impl<A, B> IsGreaterOrEqual<B> for A {
+    type Output = ();
+}
+
+impl<U> PrivateSquareRoot for U
+where
+    U: Mul,
+    Square<U>: Mul,
+    GrEq<Self, Square<Square<U>>>: Sized,
+{
+}
+
+fn main() {}

src/test/ui/feature-gates/feature-gate-associated_type_bounds.rs

@@ -1,3 +1,4 @@
+// ignore-tidy-linelength
 // compile-flags: -Zsave-analysis
 // This is also a regression test for #69415 and the above flag is needed.