Recurse into args in WF even if they have escaping bound vars

compiler-errors · compiler-errors · commit cb50caed1a1f · 2024-03-15T12:26:30.000-04:00
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -396,36 +396,17 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
             self.out.extend(obligations);
         }
 
-        self.out.extend(
-            trait_ref
-                .args
-                .iter()
-                .enumerate()
-                .filter(|(_, arg)| {
-                    matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
-                })
-                .filter(|(_, arg)| !arg.has_escaping_bound_vars())
-                .map(|(i, arg)| {
-                    let mut cause = traits::ObligationCause::misc(self.span, self.body_id);
-                    // The first arg is the self ty - use the correct span for it.
-                    if i == 0 {
-                        if let Some(hir::ItemKind::Impl(hir::Impl { self_ty, .. })) =
-                            item.map(|i| &i.kind)
-                        {
-                            cause.span = self_ty.span;
-                        }
-                    }
-                    traits::Obligation::with_depth(
-                        tcx,
-                        cause,
-                        depth,
-                        param_env,
-                        ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(
-                            arg,
-                        ))),
-                    )
-                }),
-        );
+        if let Some(hir::ItemKind::Impl(hir::Impl { self_ty, .. })) = item.map(|i| &i.kind) {
+            // FIXME: Could generalize this hack.
+            let span = std::mem::replace(&mut self.span, self_ty.span);
+            // make sure that the trait ref is WF.
+            trait_ref.args[0].visit_with(self);
+            self.span = span;
+            (&trait_ref.args[1..]).visit_with(self);
+        } else {
+            // make sure that the trait ref is WF.
+            trait_ref.visit_with(self);
+        }
     }
 
     // Compute the obligations that are required for `trait_ref` to be WF,
@@ -463,7 +444,8 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
         let obligations = self.nominal_obligations(data.def_id, data.args);
         self.out.extend(obligations);
 
-        self.compute_projection_args(data.args);
+        // Make sure that projection args are WF.
+        data.visit_with(self);
     }
 
     /// Pushes the obligations required for an inherent alias to be WF
@@ -493,33 +475,8 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
             self.out.extend(obligations);
         }
 
-        self.compute_projection_args(data.args);
-    }
-
-    fn compute_projection_args(&mut self, args: GenericArgsRef<'tcx>) {
-        let tcx = self.tcx();
-        let cause = self.cause(traits::WellFormed(None));
-        let param_env = self.param_env;
-        let depth = self.recursion_depth;
-
-        self.out.extend(
-            args.iter()
-                .filter(|arg| {
-                    matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
-                })
-                .filter(|arg| !arg.has_escaping_bound_vars())
-                .map(|arg| {
-                    traits::Obligation::with_depth(
-                        tcx,
-                        cause.clone(),
-                        depth,
-                        param_env,
-                        ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(
-                            arg,
-                        ))),
-                    )
-                }),
-        );
+        // Make sure that projection args are WF.
+        data.visit_with(self);
     }
 
     fn require_sized(&mut self, subty: Ty<'tcx>, cause: traits::ObligationCauseCode<'tcx>) {
diff --git a/tests/ui/implied-bounds/from-trait-impl.stderr b/tests/ui/implied-bounds/from-trait-impl.stderr
@@ -7,13 +7,13 @@ LL | fn func1(foo: Foo<(&str,)>) {
    = note: type must satisfy the static lifetime
 
 error[E0310]: the parameter type `X` may not live long enough
-  --> $DIR/from-trait-impl.rs:20:23
+  --> $DIR/from-trait-impl.rs:20:9
    |
 LL | impl<X> TestTrait for [Foo<(X,)>; 1] {}
-   |                       ^^^^^^^^^^^^^^
-   |                       |
-   |                       the parameter type `X` must be valid for the static lifetime...
-   |                       ...so that the type `X` will meet its required lifetime bounds
+   |         ^^^^^^^^^
+   |         |
+   |         the parameter type `X` must be valid for the static lifetime...
+   |         ...so that the type `X` will meet its required lifetime bounds
    |
 help: consider adding an explicit lifetime bound
    |
diff --git a/tests/ui/inference/issue-80409.no-compat.stderr b/tests/ui/inference/issue-80409.no-compat.stderr
diff --git a/tests/ui/inference/issue-80409.rs b/tests/ui/inference/issue-80409.rs
@@ -1,19 +1,3 @@
-// This should not pass, because `usize: Fsm` does not hold. However, it currently ICEs.
-
-// ignore-tidy-linelength
-
-//@ revisions: compat no-compat
-//@[compat] check-pass
-//@[no-compat] compile-flags: -Zno-implied-bounds-compat
-//@[no-compat] check-fail
-//@[no-compat] known-bug: #80409
-//@[no-compat] failure-status: 101
-//@[no-compat] normalize-stderr-test "delayed at.*" -> ""
-//@[no-compat] normalize-stderr-test "note: .*\n\n" -> ""
-//@[no-compat] normalize-stderr-test "thread 'rustc' panicked.*\n" -> ""
-//@[no-compat] normalize-stderr-test "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
-//@[no-compat] rustc-env:RUST_BACKTRACE=0
-
 #![allow(unreachable_code, unused)]
 
 use std::marker::PhantomData;
@@ -34,6 +18,7 @@ struct FsmStateBuilder<TFsm> {
 
 impl<TFsm> FsmStateBuilder<TFsm> {
     fn on_entry<TAction: Fn(&mut StateContext<'_, TFsm>)>(&self, _action: TAction) {}
+    //~^ ERROR the trait bound `TFsm: Fsm` is not satisfied
 }
 
 trait Fsm {
diff --git a/tests/ui/trait-bounds/unsized-bound.stderr b/tests/ui/trait-bounds/unsized-bound.stderr
@@ -1,3 +1,18 @@
+error[E0277]: the size for values of type `A` cannot be known at compilation time
+  --> $DIR/unsized-bound.rs:2:30
+   |
+LL | impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
+   |      -                       ^^^^^^ doesn't have a size known at compile-time
+   |      |
+   |      this type parameter needs to be `Sized`
+   |
+   = note: only the last element of a tuple may have a dynamically sized type
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+   |
+LL - impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
+LL + impl<A, B> Trait<(A, B)> for (A, B) where B: ?Sized, {}
+   |
+
 error[E0277]: the size for values of type `B` cannot be known at compilation time
   --> $DIR/unsized-bound.rs:2:30
    |
@@ -23,18 +38,29 @@ LL | trait Trait<A: ?Sized> {}
    |              ++++++++
 
 error[E0277]: the size for values of type `A` cannot be known at compilation time
-  --> $DIR/unsized-bound.rs:2:30
+  --> $DIR/unsized-bound.rs:5:52
    |
-LL | impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
-   |      -                       ^^^^^^ doesn't have a size known at compile-time
-   |      |
-   |      this type parameter needs to be `Sized`
+LL | impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
+   |      - this type parameter needs to be `Sized`     ^^^^^^^^^ doesn't have a size known at compile-time
    |
    = note: only the last element of a tuple may have a dynamically sized type
 help: consider removing the `?Sized` bound to make the type parameter `Sized`
    |
-LL - impl<A, B> Trait<(A, B)> for (A, B) where A: ?Sized, B: ?Sized, {}
-LL + impl<A, B> Trait<(A, B)> for (A, B) where B: ?Sized, {}
+LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
+LL + impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C)  {}
+   |
+
+error[E0277]: the size for values of type `B` cannot be known at compilation time
+  --> $DIR/unsized-bound.rs:5:52
+   |
+LL | impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
+   |         - this type parameter needs to be `Sized`  ^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = note: only the last element of a tuple may have a dynamically sized type
+help: consider removing the `?Sized` bound to make the type parameter `Sized`
+   |
+LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
+LL + impl<A, B, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
    |
 
 error[E0277]: the size for values of type `C` cannot be known at compilation time
@@ -62,29 +88,18 @@ LL | trait Trait<A: ?Sized> {}
    |              ++++++++
 
 error[E0277]: the size for values of type `A` cannot be known at compilation time
-  --> $DIR/unsized-bound.rs:5:52
-   |
-LL | impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
-   |      - this type parameter needs to be `Sized`     ^^^^^^^^^ doesn't have a size known at compile-time
-   |
-   = note: only the last element of a tuple may have a dynamically sized type
-help: consider removing the `?Sized` bound to make the type parameter `Sized`
-   |
-LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
-LL + impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C)  {}
-   |
-
-error[E0277]: the size for values of type `B` cannot be known at compilation time
-  --> $DIR/unsized-bound.rs:5:52
+  --> $DIR/unsized-bound.rs:10:47
    |
-LL | impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
-   |         - this type parameter needs to be `Sized`  ^^^^^^^^^ doesn't have a size known at compile-time
+LL | impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
+   |      -                                        ^^^^^^ doesn't have a size known at compile-time
+   |      |
+   |      this type parameter needs to be `Sized`
    |
    = note: only the last element of a tuple may have a dynamically sized type
 help: consider removing the `?Sized` bound to make the type parameter `Sized`
    |
-LL - impl<A, B: ?Sized, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
-LL + impl<A, B, C: ?Sized> Trait<(A, B, C)> for (A, B, C) where A: ?Sized, {}
+LL - impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
+LL + impl<A, B: ?Sized> Trait2<(A, B)> for (A, B) {}
    |
 
 error[E0277]: the size for values of type `B` cannot be known at compilation time
@@ -111,21 +126,6 @@ help: consider relaxing the implicit `Sized` restriction
 LL | trait Trait2<A: ?Sized> {}
    |               ++++++++
 
-error[E0277]: the size for values of type `A` cannot be known at compilation time
-  --> $DIR/unsized-bound.rs:10:47
-   |
-LL | impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
-   |      -                                        ^^^^^^ doesn't have a size known at compile-time
-   |      |
-   |      this type parameter needs to be `Sized`
-   |
-   = note: only the last element of a tuple may have a dynamically sized type
-help: consider removing the `?Sized` bound to make the type parameter `Sized`
-   |
-LL - impl<A: ?Sized, B: ?Sized> Trait2<(A, B)> for (A, B) {}
-LL + impl<A, B: ?Sized> Trait2<(A, B)> for (A, B) {}
-   |
-
 error[E0277]: the size for values of type `A` cannot be known at compilation time
   --> $DIR/unsized-bound.rs:14:23
    |
diff --git a/tests/ui/traits/copy-impl-cannot-normalize.stderr b/tests/ui/traits/copy-impl-cannot-normalize.stderr
@@ -2,18 +2,16 @@ error[E0277]: the trait bound `T: TraitFoo` is not satisfied
   --> $DIR/copy-impl-cannot-normalize.rs:22:18
    |
 LL | impl<T> Copy for Foo<T> {}
-   |                  ^^^^^^ the trait `TraitFoo` is not implemented for `T`, which is required by `Foo<T>: Clone`
+   |                  ^^^^^^ the trait `TraitFoo` is not implemented for `T`
    |
-note: required for `Foo<T>` to implement `Clone`
-  --> $DIR/copy-impl-cannot-normalize.rs:12:9
+note: required by a bound in `Foo`
+  --> $DIR/copy-impl-cannot-normalize.rs:7:8
    |
-LL | impl<T> Clone for Foo<T>
-   |         ^^^^^     ^^^^^^
+LL | struct Foo<T>
+   |        --- required by a bound in this struct
 LL | where
 LL |     T: TraitFoo,
-   |        -------- unsatisfied trait bound introduced here
-note: required by a bound in `Copy`
-  --> $SRC_DIR/core/src/marker.rs:LL:COL
+   |        ^^^^^^^^ required by this bound in `Foo`
 help: consider restricting type parameter `T`
    |
 LL | impl<T: TraitFoo> Copy for Foo<T> {}
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
@@ -19,12 +19,6 @@ error[E0275]: overflow evaluating the requirement `<() as A<T>>::Assoc: A<T>`
 LL |         Self::Assoc: A<T>,
    |                      ^^^^
 
-error[E0275]: overflow evaluating the requirement `<() as A<T>>::Assoc well-formed`
-  --> $DIR/normalize-param-env-2.rs:24:22
-   |
-LL |         Self::Assoc: A<T>,
-   |                      ^^^^
-
 error[E0275]: overflow evaluating the requirement `(): A<T>`
   --> $DIR/normalize-param-env-2.rs:27:10
    |
@@ -46,6 +40,6 @@ LL |     where
 LL |         Self::Assoc: A<T>,
    |                      ^^^^ required by this bound in `A::f`
 
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/normalize/normalize-param-env-4.next.stderr b/tests/ui/traits/next-solver/normalize/normalize-param-env-4.next.stderr
@@ -4,12 +4,6 @@ error[E0275]: overflow evaluating the requirement `<T as Trait>::Assoc: Trait`
 LL |     <T as Trait>::Assoc: Trait,
    |                          ^^^^^
 
-error[E0275]: overflow evaluating the requirement `<T as Trait>::Assoc well-formed`
-  --> $DIR/normalize-param-env-4.rs:19:26
-   |
-LL |     <T as Trait>::Assoc: Trait,
-   |                          ^^^^^
-
 error[E0275]: overflow evaluating the requirement `T: Trait`
   --> $DIR/normalize-param-env-4.rs:32:19
    |
@@ -22,6 +16,6 @@ note: required by a bound in `impls_trait`
 LL | fn impls_trait<T: Trait>() {}
    |                   ^^^^^ required by this bound in `impls_trait`
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0275`.

Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,13 @@ LL \| fn func1(foo: Foo<(&str,)>) {`
`7`	`7`	`= note: type must satisfy the static lifetime`
`8`	`8`
`9`	`9`	error[E0310]: the parameter type `X` may not live long enough
`10`		`- --> $DIR/from-trait-impl.rs:20:23`
	`10`	`+ --> $DIR/from-trait-impl.rs:20:9`
`11`	`11`	`\|`
`12`	`12`	`LL \| impl<X> TestTrait for [Foo<(X,)>; 1] {}`
`13`		`- \| ^^^^^^^^^^^^^^`
`14`		`- \| \|`
`15`		- \| the parameter type `X` must be valid for the static lifetime...
`16`		- \| ...so that the type `X` will meet its required lifetime bounds
	`13`	`+ \| ^^^^^^^^^`
	`14`	`+ \| \|`
	`15`	+ \| the parameter type `X` must be valid for the static lifetime...
	`16`	+ \| ...so that the type `X` will meet its required lifetime bounds
`17`	`17`	`\|`
`18`	`18`	`help: consider adding an explicit lifetime bound`
`19`	`19`	`\|`