diff options
Diffstat (limited to 'tests/ui/higher-rank-trait-bounds')
102 files changed, 0 insertions, 3294 deletions
diff --git a/tests/ui/higher-rank-trait-bounds/complex.rs b/tests/ui/higher-rank-trait-bounds/complex.rs deleted file mode 100644 index 8cdfe247e..000000000 --- a/tests/ui/higher-rank-trait-bounds/complex.rs +++ /dev/null @@ -1,28 +0,0 @@ -// check-pass - -trait A<'a> {} -trait B<'b> {} -fn foo<T>() where for<'a> T: A<'a> + 'a {} -trait C<'c>: for<'a> A<'a> + for<'b> B<'b> { - type As; -} -struct D<T> where T: for<'c> C<'c, As=&'c ()> { - t: std::marker::PhantomData<T>, -} -trait E<'e, 'g> { - type As; -} -trait F<'f>: for<'a> A<'a> + for<'e> E<'e, 'f> {} -struct G<T> where T: for<'f> F<'f, As=&'f ()> { - t: std::marker::PhantomData<T>, -} -trait H<'a, 'b> { - type As; -} -trait I<'a>: for<'b> H<'a, 'b> {} - -struct J<T> where T: for<'i> I<'i, As=&'i ()> { - t: std::marker::PhantomData<T>, -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/due-to-where-clause.rs b/tests/ui/higher-rank-trait-bounds/due-to-where-clause.rs deleted file mode 100644 index 1afd15613..000000000 --- a/tests/ui/higher-rank-trait-bounds/due-to-where-clause.rs +++ /dev/null @@ -1,13 +0,0 @@ -fn main() { - test::<FooS>(&mut 42); //~ ERROR implementation of `Foo` is not general enough -} - -trait Foo<'a> {} - -struct FooS<'a> { - data: &'a mut u32, -} - -impl<'a, 'b: 'a> Foo<'b> for FooS<'a> {} - -fn test<'a, F>(data: &'a mut u32) where F: for<'b> Foo<'b> {} diff --git a/tests/ui/higher-rank-trait-bounds/due-to-where-clause.stderr b/tests/ui/higher-rank-trait-bounds/due-to-where-clause.stderr deleted file mode 100644 index 520938a63..000000000 --- a/tests/ui/higher-rank-trait-bounds/due-to-where-clause.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error: implementation of `Foo` is not general enough - --> $DIR/due-to-where-clause.rs:2:5 - | -LL | test::<FooS>(&mut 42); - | ^^^^^^^^^^^^ implementation of `Foo` is not general enough - | - = note: `FooS<'_>` must implement `Foo<'0>`, for any lifetime `'0`... - = note: ...but `FooS<'_>` actually implements `Foo<'1>`, for some specific lifetime `'1` - -error: aborting due to previous error - diff --git a/tests/ui/higher-rank-trait-bounds/fn-ptr.classic.stderr b/tests/ui/higher-rank-trait-bounds/fn-ptr.classic.stderr deleted file mode 100644 index 9af6bc45c..000000000 --- a/tests/ui/higher-rank-trait-bounds/fn-ptr.classic.stderr +++ /dev/null @@ -1,19 +0,0 @@ -error[E0277]: expected a `Fn<(&'w (),)>` closure, found `fn(&'w ())` - --> $DIR/fn-ptr.rs:12:5 - | -LL | ice(); - | ^^^ expected an `Fn<(&'w (),)>` closure, found `fn(&'w ())` - | - = help: the trait `for<'w> Fn<(&'w (),)>` is not implemented for `fn(&'w ())` -note: required by a bound in `ice` - --> $DIR/fn-ptr.rs:7:25 - | -LL | fn ice() - | --- required by a bound in this function -LL | where -LL | for<'w> fn(&'w ()): Fn(&'w ()), - | ^^^^^^^^^^ required by this bound in `ice` - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/higher-rank-trait-bounds/fn-ptr.rs b/tests/ui/higher-rank-trait-bounds/fn-ptr.rs deleted file mode 100644 index 853160f96..000000000 --- a/tests/ui/higher-rank-trait-bounds/fn-ptr.rs +++ /dev/null @@ -1,14 +0,0 @@ -// revisions: classic next -//[next] compile-flags: -Ztrait-solver=next -//[next] check-pass - -fn ice() -where - for<'w> fn(&'w ()): Fn(&'w ()), -{ -} - -fn main() { - ice(); - //[classic]~^ ERROR expected a `Fn<(&'w (),)>` closure, found `fn(&'w ())` -} diff --git a/tests/ui/higher-rank-trait-bounds/hang-on-deeply-nested-dyn.rs b/tests/ui/higher-rank-trait-bounds/hang-on-deeply-nested-dyn.rs deleted file mode 100644 index d34b7a296..000000000 --- a/tests/ui/higher-rank-trait-bounds/hang-on-deeply-nested-dyn.rs +++ /dev/null @@ -1,16 +0,0 @@ -// normalize-stderr-test: "long-type-\d+" -> "long-type-hash" - -fn id( - f: &dyn Fn(u32), -) -> &dyn Fn( - &dyn Fn( - &dyn Fn( - &dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(u32))))))))), - ), - ), -) { - f - //~^ ERROR mismatched types -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hang-on-deeply-nested-dyn.stderr b/tests/ui/higher-rank-trait-bounds/hang-on-deeply-nested-dyn.stderr deleted file mode 100644 index 3662cbfb9..000000000 --- a/tests/ui/higher-rank-trait-bounds/hang-on-deeply-nested-dyn.stderr +++ /dev/null @@ -1,22 +0,0 @@ -error[E0308]: mismatched types - --> $DIR/hang-on-deeply-nested-dyn.rs:12:5 - | -LL | ) -> &dyn Fn( - | ______- -LL | | &dyn Fn( -LL | | &dyn Fn( -LL | | &dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(u32))))))))), -LL | | ), -LL | | ), -LL | | ) { - | |_- expected `&dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn for<'a> Fn(&'a (dyn Fn(u32) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a)) + 'a))` because of return type -LL | f - | ^ expected `&dyn Fn(&dyn Fn(&dyn Fn(&...)))`, found `&dyn Fn(u32)` - | - = note: expected reference `&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&dyn Fn(&...)))))))))))` - the full type name has been written to '$TEST_BUILD_DIR/higher-rank-trait-bounds/hang-on-deeply-nested-dyn/hang-on-deeply-nested-dyn.long-type-hash.txt' - found reference `&dyn Fn(u32)` - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-binder-levels-in-object-types.rs b/tests/ui/higher-rank-trait-bounds/hrtb-binder-levels-in-object-types.rs deleted file mode 100644 index cc766c060..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-binder-levels-in-object-types.rs +++ /dev/null @@ -1,29 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![allow(unused_variables)] -// Test that we handle binder levels in object types correctly. -// Initially, the reference to `'tcx` in the object type -// `&Typer<'tcx>` was getting an incorrect binder level, yielding -// weird compilation ICEs and so forth. - -// pretty-expanded FIXME #23616 - -trait Typer<'tcx> { - fn method(&self, data: &'tcx isize) -> &'tcx isize { data } -} - -struct Tcx<'tcx> { - fields: &'tcx isize -} - -impl<'tcx> Typer<'tcx> for Tcx<'tcx> { -} - -fn g<'tcx>(typer: &dyn Typer<'tcx>) { -} - -fn check_static_type<'x>(tcx: &Tcx<'x>) { - g(tcx) -} - -fn main() { } diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.rs b/tests/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.rs deleted file mode 100644 index a20d03c77..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.rs +++ /dev/null @@ -1,24 +0,0 @@ -// Regression test for #54302. -// -// We were incorrectly using the "evaluation cache" (which ignored -// region results) to conclude that `&'static str: Deserialize`, even -// though it would require that `for<'de> 'de: 'static`, which is -// clearly false. - -trait Deserialize<'de> {} - -trait DeserializeOwned: for<'de> Deserialize<'de> {} -impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {} - -// Based on this impl, `&'static str` only implements Deserialize<'static>. -// It does not implement for<'de> Deserialize<'de>. -impl<'de: 'a, 'a> Deserialize<'de> for &'a str {} - -fn main() { - fn assert_deserialize_owned<T: DeserializeOwned>() {} - assert_deserialize_owned::<&'static str>(); //~ ERROR - - // It correctly does not implement for<'de> Deserialize<'de>. - // fn assert_hrtb<T: for<'de> Deserialize<'de>>() {} - // assert_hrtb::<&'static str>(); -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.stderr deleted file mode 100644 index f014eab86..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-cache-issue-54302.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error: implementation of `Deserialize` is not general enough - --> $DIR/hrtb-cache-issue-54302.rs:19:5 - | -LL | assert_deserialize_owned::<&'static str>(); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Deserialize` is not general enough - | - = note: `&'static str` must implement `Deserialize<'0>`, for any lifetime `'0`... - = note: ...but `&str` actually implements `Deserialize<'1>`, for some specific lifetime `'1` - -error: aborting due to previous error - diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-conflate-regions.rs b/tests/ui/higher-rank-trait-bounds/hrtb-conflate-regions.rs deleted file mode 100644 index e83686404..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-conflate-regions.rs +++ /dev/null @@ -1,31 +0,0 @@ -// Test that an impl with only one bound region `'a` cannot be used to -// satisfy a constraint where there are two bound regions. - -trait Foo<X> { - fn foo(&self, x: X) { } -} - -fn want_foo2<T>() - where T : for<'a,'b> Foo<(&'a isize, &'b isize)> -{ -} - -fn want_foo1<T>() - where T : for<'z> Foo<(&'z isize, &'z isize)> -{ -} - -// Expressed as a where clause - -struct SomeStruct; - -impl<'a> Foo<(&'a isize, &'a isize)> for SomeStruct -{ -} - -fn a() { want_foo1::<SomeStruct>(); } // OK -- foo wants just one region -fn b() { want_foo2::<SomeStruct>(); } -//~^ ERROR implementation of -//~| ERROR implementation of - -fn main() { } diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-conflate-regions.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-conflate-regions.stderr deleted file mode 100644 index 46f5308dd..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-conflate-regions.stderr +++ /dev/null @@ -1,20 +0,0 @@ -error: implementation of `Foo` is not general enough - --> $DIR/hrtb-conflate-regions.rs:27:10 - | -LL | fn b() { want_foo2::<SomeStruct>(); } - | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough - | - = note: `SomeStruct` must implement `Foo<(&'0 isize, &'1 isize)>`, for any two lifetimes `'0` and `'1`... - = note: ...but it actually implements `Foo<(&'2 isize, &'2 isize)>`, for some specific lifetime `'2` - -error: implementation of `Foo` is not general enough - --> $DIR/hrtb-conflate-regions.rs:27:10 - | -LL | fn b() { want_foo2::<SomeStruct>(); } - | ^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough - | - = note: `SomeStruct` must implement `Foo<(&'0 isize, &'1 isize)>`, for any two lifetimes `'0` and `'1`... - = note: ...but it actually implements `Foo<(&'2 isize, &'2 isize)>`, for some specific lifetime `'2` - -error: aborting due to 2 previous errors - diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.rs b/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.rs deleted file mode 100644 index 05d3e1a43..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.rs +++ /dev/null @@ -1,18 +0,0 @@ -// Test the case where the `Self` type has a bound lifetime that must -// be adjusted in the fn signature. Issue #19537. - -use std::collections::HashMap; - -struct Foo<'a> { - map: HashMap<usize, &'a str> -} - -impl<'a> Foo<'a> { - fn new() -> Foo<'a> { panic!() } - fn insert(&'a mut self) { } -} -fn main() { - let mut foo = Foo::new(); - foo.insert(); - foo.insert(); //~ ERROR cannot borrow -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.stderr deleted file mode 100644 index fa391ecba..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-in-receiver.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error[E0499]: cannot borrow `foo` as mutable more than once at a time - --> $DIR/hrtb-debruijn-in-receiver.rs:17:5 - | -LL | foo.insert(); - | ------------ first mutable borrow occurs here -LL | foo.insert(); - | ^^^^^^^^^^^^ - | | - | second mutable borrow occurs here - | first borrow later used here - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0499`. diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-object-types-in-closures.rs b/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-object-types-in-closures.rs deleted file mode 100644 index 8431226a3..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-debruijn-object-types-in-closures.rs +++ /dev/null @@ -1,16 +0,0 @@ -// run-pass -#![allow(dead_code)] -// pretty-expanded FIXME #23616 - -trait Typer<'tcx> { - fn method(&self, data: &'tcx isize) -> &'tcx isize { data } - fn dummy(&self) { } -} - -fn g<F>(_: F) where F: FnOnce(&dyn Typer) {} - -fn h() { - g(|typer| typer.dummy()) -} - -fn main() { } diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.rs b/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.rs deleted file mode 100644 index 567802376..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.rs +++ /dev/null @@ -1,18 +0,0 @@ -// Test an `exists<'a> { forall<'b> { 'a = 'b } }` pattern -- which should not compile! -// -// In particular, we test this pattern in trait solving, where it is not connected -// to any part of the source code. - -fn foo<'a>() -> fn(&'a u32) { - panic!() -} - -fn main() { - // Here, proving that `fn(&'a u32) <: for<'b> fn(&'b u32)`: - // - // - instantiates `'b` with a placeholder `!b`, - // - requires that `&!b u32 <: &'a u32` and hence that `!b: 'a`, - // - but we can never know this. - - let _: for<'b> fn(&'b u32) = foo(); //~ ERROR mismatched types -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.stderr deleted file mode 100644 index 9914783d9..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-fn.stderr +++ /dev/null @@ -1,12 +0,0 @@ -error[E0308]: mismatched types - --> $DIR/hrtb-exists-forall-fn.rs:17:34 - | -LL | let _: for<'b> fn(&'b u32) = foo(); - | ^^^^^ one type is more general than the other - | - = note: expected fn pointer `for<'b> fn(&'b u32)` - found fn pointer `fn(&u32)` - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.rs b/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.rs deleted file mode 100644 index 921061916..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.rs +++ /dev/null @@ -1,36 +0,0 @@ -// Test a case where variance and higher-ranked types interact in surprising ways. -// -// In particular, we test this pattern in trait solving, where it is not connected -// to any part of the source code. - -trait Trait<T> {} - -fn foo<T>() -where - T: Trait<for<'b> fn(&'b u32)>, -{ -} - -impl<'a> Trait<fn(&'a u32)> for () {} - -fn main() { - // Here, proving that `(): Trait<for<'b> fn(&'b u32)>` uses the impl: - // - // - The impl provides the clause `forall<'a> { (): Trait<fn(&'a u32)> }` - // - We instantiate `'a` existentially to get `(): Trait<fn(&?a u32)>` - // - We unify `fn(&?a u32)` with `for<'b> fn(&'b u32)` -- this does a - // "bidirectional" subtyping check, so we wind up with: - // - `fn(&?a u32) <: for<'b> fn(&'b u32)` :- - // - `&'!b u32 <: &?a u32` - // - `!'b: ?a` -- solveable if `?a` is inferred to `'empty` - // - `for<'b> fn(&'b u32) <: fn(&?a u32)` :- - // - `&?a u32 u32 <: &?b u32` - // - `?a: ?b` -- solveable if `?b` is also inferred to `'empty` - // - So the subtyping check succeeds, somewhat surprisingly. - // This is because we can use `'empty`. - // - // NB. *However*, the reinstated leak-check gives an error here. - - foo::<()>(); - //~^ ERROR implementation of `Trait` is not general enough -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.stderr deleted file mode 100644 index 364b613fc..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-contravariant.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error: implementation of `Trait` is not general enough - --> $DIR/hrtb-exists-forall-trait-contravariant.rs:34:5 - | -LL | foo::<()>(); - | ^^^^^^^^^^^ implementation of `Trait` is not general enough - | - = note: `()` must implement `Trait<for<'b> fn(&'b u32)>` - = note: ...but it actually implements `Trait<fn(&'0 u32)>`, for some specific lifetime `'0` - -error: aborting due to previous error - diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-covariant.rs b/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-covariant.rs deleted file mode 100644 index f95496a6c..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-covariant.rs +++ /dev/null @@ -1,37 +0,0 @@ -// Test a case where variance and higher-ranked types interact in surprising ways. -// -// In particular, we test this pattern in trait solving, where it is not connected -// to any part of the source code. -// -// check-pass - -trait Trait<T> {} - -fn foo<T>() -where - T: Trait<for<'b> fn(fn(&'b u32))>, -{ -} - -impl<'a> Trait<fn(fn(&'a u32))> for () {} - -fn main() { - // Here, proving that `(): Trait<for<'b> fn(&'b u32)>` uses the impl: - // - // - The impl provides the clause `forall<'a> { (): Trait<fn(fn(&'a u32))> }` - // - We instantiate `'a` existentially to get `(): Trait<fn(fn(&?a u32))>` - // - We unify `fn(fn(&?a u32))` with `for<'b> fn(fn(&'b u32))` -- this does a - // "bidirectional" subtyping check, so we wind up with: - // - `fn(fn(&?a u32)) <: for<'b> fn(fn(&'b u32))` :- - // - `fn(&!b u32) <: fn(&?a u32)` - // - `&?a u32 <: &!b u32` - // - `?a: !'b` -- solveable if `?a` is inferred to `'static` - // - `for<'b> fn(fn(&'b u32)) <: fn(fn(&?a u32))` :- - // - `fn(&?a u32) <: fn(&?b u32)` - // - `&?b u32 <: &?a u32` - // - `?b: ?a` -- solveable if `?b` is inferred to `'static` - // - So the subtyping check succeeds, somewhat surprisingly. - // This is because we can use `'static`. - - foo::<()>(); -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.rs b/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.rs deleted file mode 100644 index 9b9e4496a..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.rs +++ /dev/null @@ -1,29 +0,0 @@ -// Test an `exists<'a> { forall<'b> { 'a = 'b } }` pattern -- which should not compile! -// -// In particular, we test this pattern in trait solving, where it is not connected -// to any part of the source code. - -use std::cell::Cell; - -trait Trait<T> {} - -fn foo<T>() -where - T: Trait<for<'b> fn(Cell<&'b u32>)>, -{ -} - -impl<'a> Trait<fn(Cell<&'a u32>)> for () {} - -fn main() { - // Here, proving that `(): Trait<for<'b> fn(&'b u32)>` uses the impl: - // - // - The impl provides the clause `forall<'a> { (): Trait<fn(&'a u32)> }` - // - We instantiate `'a` existentially to get `(): Trait<fn(&?a u32)>` - // - We unify `fn(&?a u32)` with `for<'b> fn(&'b u32)` - // - This requires (among other things) instantiating `'b` universally, - // yielding `fn(&!b u32)`, in a fresh universe U1 - // - So we get `?a = !b` but the universe U0 assigned to `?a` cannot name `!b`. - - foo::<()>(); //~ ERROR implementation of `Trait` is not general enough -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.stderr deleted file mode 100644 index cb2ce8a41..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-exists-forall-trait-invariant.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error: implementation of `Trait` is not general enough - --> $DIR/hrtb-exists-forall-trait-invariant.rs:28:5 - | -LL | foo::<()>(); - | ^^^^^^^^^^^ implementation of `Trait` is not general enough - | - = note: `()` must implement `Trait<for<'b> fn(Cell<&'b u32>)>` - = note: ...but it actually implements `Trait<fn(Cell<&'0 u32>)>`, for some specific lifetime `'0` - -error: aborting due to previous error - diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-fn-like-trait-object.rs b/tests/ui/higher-rank-trait-bounds/hrtb-fn-like-trait-object.rs deleted file mode 100644 index ff84ad9d2..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-fn-like-trait-object.rs +++ /dev/null @@ -1,27 +0,0 @@ -// run-pass -// A basic test of using a higher-ranked trait bound. - - -trait FnLike<A,R> { - fn call(&self, arg: A) -> R; -} - -type FnObject<'b> = dyn for<'a> FnLike<&'a isize, &'a isize> + 'b; - -struct Identity; - -impl<'a, T> FnLike<&'a T, &'a T> for Identity { - fn call(&self, arg: &'a T) -> &'a T { - arg - } -} - -fn call_repeatedly(f: &FnObject) { - let x = 3; - let y = f.call(&x); - assert_eq!(3, *y); -} - -fn main() { - call_repeatedly(&Identity); -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-fn-like-trait.rs b/tests/ui/higher-rank-trait-bounds/hrtb-fn-like-trait.rs deleted file mode 100644 index afab9986c..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-fn-like-trait.rs +++ /dev/null @@ -1,27 +0,0 @@ -// run-pass -// A basic test of using a higher-ranked trait bound. - - -trait FnLike<A,R> { - fn call(&self, arg: A) -> R; -} - -struct Identity; - -impl<'a, T> FnLike<&'a T, &'a T> for Identity { - fn call(&self, arg: &'a T) -> &'a T { - arg - } -} - -fn call_repeatedly<F>(f: F) - where F : for<'a> FnLike<&'a isize, &'a isize> -{ - let x = 3; - let y = f.call(&x); - assert_eq!(3, *y); -} - -fn main() { - call_repeatedly(Identity); -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.rs b/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.rs deleted file mode 100644 index f9ae1429e..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.rs +++ /dev/null @@ -1,50 +0,0 @@ -// Test HRTB supertraits with several levels of expansion required. - -trait Foo<'tcx> -{ - fn foo(&'tcx self) -> &'tcx isize; -} - -trait Bar<'ccx> - : for<'tcx> Foo<'tcx> -{ - fn bar(&'ccx self) -> &'ccx isize; -} - -trait Baz - : for<'ccx> Bar<'ccx> -{ - fn dummy(&self); -} - -trait Qux - : Bar<'static> -{ - fn dummy(&self); -} - -fn want_foo_for_any_tcx<F>(f: &F) - where F : for<'tcx> Foo<'tcx> -{ -} - -fn want_bar_for_any_ccx<B>(b: &B) - where B : for<'ccx> Bar<'ccx> -{ -} - -fn want_baz<B>(b: &B) - where B : Baz -{ - want_foo_for_any_tcx(b); - want_bar_for_any_ccx(b); -} - -fn want_qux<B>(b: &B) - where B : Qux -{ - want_foo_for_any_tcx(b); - want_bar_for_any_ccx(b); //~ ERROR -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr deleted file mode 100644 index b1b8ffa8c..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits-transitive.stderr +++ /dev/null @@ -1,23 +0,0 @@ -error[E0277]: the trait bound `for<'ccx> B: Bar<'ccx>` is not satisfied - --> $DIR/hrtb-higher-ranker-supertraits-transitive.rs:47:26 - | -LL | want_bar_for_any_ccx(b); - | -------------------- ^ the trait `for<'ccx> Bar<'ccx>` is not implemented for `B` - | | - | required by a bound introduced by this call - | -note: required by a bound in `want_bar_for_any_ccx` - --> $DIR/hrtb-higher-ranker-supertraits-transitive.rs:32:15 - | -LL | fn want_bar_for_any_ccx<B>(b: &B) - | -------------------- required by a bound in this function -LL | where B : for<'ccx> Bar<'ccx> - | ^^^^^^^^^^^^^^^^^^^ required by this bound in `want_bar_for_any_ccx` -help: consider further restricting this bound - | -LL | where B : Qux + for<'ccx> Bar<'ccx> - | +++++++++++++++++++++ - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.rs b/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.rs deleted file mode 100644 index 48ebe5017..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.rs +++ /dev/null @@ -1,48 +0,0 @@ -// Test a trait (`Bar`) with a higher-ranked supertrait. - -trait Foo<'tcx> -{ - fn foo(&'tcx self) -> &'tcx isize; -} - -trait Bar<'ccx> - : for<'tcx> Foo<'tcx> -{ - fn bar(&'ccx self) -> &'ccx isize; -} - -fn want_foo_for_some_tcx<'x,F>(f: &'x F) - where F : Foo<'x> -{ - want_foo_for_some_tcx(f); - want_foo_for_any_tcx(f); //~ ERROR not satisfied -} - -fn want_foo_for_any_tcx<F>(f: &F) - where F : for<'tcx> Foo<'tcx> -{ - want_foo_for_some_tcx(f); - want_foo_for_any_tcx(f); -} - -fn want_bar_for_some_ccx<'x,B>(b: &B) - where B : Bar<'x> -{ - want_foo_for_some_tcx(b); - want_foo_for_any_tcx(b); - - want_bar_for_some_ccx(b); - want_bar_for_any_ccx(b); //~ ERROR not satisfied -} - -fn want_bar_for_any_ccx<B>(b: &B) - where B : for<'ccx> Bar<'ccx> -{ - want_foo_for_some_tcx(b); - want_foo_for_any_tcx(b); - - want_bar_for_some_ccx(b); - want_bar_for_any_ccx(b); -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.stderr deleted file mode 100644 index 7f96909b6..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-higher-ranker-supertraits.stderr +++ /dev/null @@ -1,43 +0,0 @@ -error[E0277]: the trait bound `for<'tcx> F: Foo<'tcx>` is not satisfied - --> $DIR/hrtb-higher-ranker-supertraits.rs:18:26 - | -LL | want_foo_for_any_tcx(f); - | -------------------- ^ the trait `for<'tcx> Foo<'tcx>` is not implemented for `F` - | | - | required by a bound introduced by this call - | -note: required by a bound in `want_foo_for_any_tcx` - --> $DIR/hrtb-higher-ranker-supertraits.rs:22:15 - | -LL | fn want_foo_for_any_tcx<F>(f: &F) - | -------------------- required by a bound in this function -LL | where F : for<'tcx> Foo<'tcx> - | ^^^^^^^^^^^^^^^^^^^ required by this bound in `want_foo_for_any_tcx` -help: consider further restricting this bound - | -LL | where F : Foo<'x> + for<'tcx> Foo<'tcx> - | +++++++++++++++++++++ - -error[E0277]: the trait bound `for<'ccx> B: Bar<'ccx>` is not satisfied - --> $DIR/hrtb-higher-ranker-supertraits.rs:35:26 - | -LL | want_bar_for_any_ccx(b); - | -------------------- ^ the trait `for<'ccx> Bar<'ccx>` is not implemented for `B` - | | - | required by a bound introduced by this call - | -note: required by a bound in `want_bar_for_any_ccx` - --> $DIR/hrtb-higher-ranker-supertraits.rs:39:15 - | -LL | fn want_bar_for_any_ccx<B>(b: &B) - | -------------------- required by a bound in this function -LL | where B : for<'ccx> Bar<'ccx> - | ^^^^^^^^^^^^^^^^^^^ required by this bound in `want_bar_for_any_ccx` -help: consider further restricting this bound - | -LL | where B : Bar<'x> + for<'ccx> Bar<'ccx> - | +++++++++++++++++++++ - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.rs b/tests/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.rs deleted file mode 100644 index 89fc4705a..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.rs +++ /dev/null @@ -1,26 +0,0 @@ -// Test that the `'a` in the where clause correctly links the region -// of the output to the region of the input. - -trait FnLike<A,R> { - fn call(&self, arg: A) -> R; -} - -fn call_repeatedly<F>(f: F) - where F : for<'a> FnLike<&'a isize, &'a isize> -{ - // Result is stored: cannot re-assign `x` - let mut x = 3; - let y = f.call(&x); - x = 5; //~ ERROR cannot assign to `x` because it is borrowed - - // Result is not stored: can re-assign `x` - let mut x = 3; - f.call(&x); - f.call(&x); - f.call(&x); - x = 5; - drop(y); -} - -fn main() { -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.stderr deleted file mode 100644 index 25af011e3..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-identity-fn-borrows.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error[E0506]: cannot assign to `x` because it is borrowed - --> $DIR/hrtb-identity-fn-borrows.rs:14:5 - | -LL | let y = f.call(&x); - | -- `x` is borrowed here -LL | x = 5; - | ^^^^^ `x` is assigned to here but it was already borrowed -... -LL | drop(y); - | - borrow later used here - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0506`. diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-just-for-static.rs b/tests/ui/higher-rank-trait-bounds/hrtb-just-for-static.rs deleted file mode 100644 index 8fb4218f8..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-just-for-static.rs +++ /dev/null @@ -1,35 +0,0 @@ -// Test a case where you have an impl of `Foo<X>` for all `X` that -// is being applied to `for<'a> Foo<&'a mut X>`. Issue #19730. - -trait Foo<X> { - fn foo(&self, x: X) { } -} - -fn want_hrtb<T>() - where T : for<'a> Foo<&'a isize> -{ -} - -// AnyInt implements Foo<&'a isize> for any 'a, so it is a match. -struct AnyInt; -impl<'a> Foo<&'a isize> for AnyInt { } -fn give_any() { - want_hrtb::<AnyInt>() -} - -// StaticInt only implements Foo<&'static isize>, so it is an error. -struct StaticInt; -impl Foo<&'static isize> for StaticInt { } -fn give_static() { - want_hrtb::<StaticInt>() //~ ERROR -} - -// &'a u32 only implements Foo<&'a isize> for specific 'a, so it is an error. -impl<'a> Foo<&'a isize> for &'a u32 { } -fn give_some<'a>() { - want_hrtb::<&'a u32>() - //~^ ERROR lifetime may not live long enough - //~| ERROR implementation of `Foo` is not general enough -} - -fn main() { } diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-just-for-static.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-just-for-static.stderr deleted file mode 100644 index 31e11e128..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-just-for-static.stderr +++ /dev/null @@ -1,34 +0,0 @@ -error: implementation of `Foo` is not general enough - --> $DIR/hrtb-just-for-static.rs:24:5 - | -LL | want_hrtb::<StaticInt>() - | ^^^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough - | - = note: `StaticInt` must implement `Foo<&'0 isize>`, for any lifetime `'0`... - = note: ...but it actually implements `Foo<&'static isize>` - -error: lifetime may not live long enough - --> $DIR/hrtb-just-for-static.rs:30:5 - | -LL | fn give_some<'a>() { - | -- lifetime `'a` defined here -LL | want_hrtb::<&'a u32>() - | ^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static` - | -note: due to current limitations in the borrow checker, this implies a `'static` lifetime - --> $DIR/hrtb-just-for-static.rs:9:15 - | -LL | where T : for<'a> Foo<&'a isize> - | ^^^^^^^^^^^^^^^^^^^^^^ - -error: implementation of `Foo` is not general enough - --> $DIR/hrtb-just-for-static.rs:30:5 - | -LL | want_hrtb::<&'a u32>() - | ^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough - | - = note: `Foo<&'0 isize>` would have to be implemented for the type `&u32`, for any lifetime `'0`... - = note: ...but `Foo<&'1 isize>` is actually implemented for the type `&'1 u32`, for some specific lifetime `'1` - -error: aborting due to 3 previous errors - diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-malformed-lifetime-generics.rs b/tests/ui/higher-rank-trait-bounds/hrtb-malformed-lifetime-generics.rs deleted file mode 100644 index 4b096be59..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-malformed-lifetime-generics.rs +++ /dev/null @@ -1,20 +0,0 @@ -// Test that Fn-family traits with lifetime parameters shouldn't compile and -// we suggest the usage of higher-rank trait bounds instead. - -fn fa(_: impl Fn<'a>(&'a str) -> bool) {} -//~^ ERROR `Fn` traits cannot take lifetime parameters - -fn fb(_: impl FnMut<'a, 'b>(&'a str, &'b str) -> bool) {} -//~^ ERROR `Fn` traits cannot take lifetime parameters - -fn fc(_: impl std::fmt::Display + FnOnce<'a>(&'a str) -> bool + std::fmt::Debug) {} -//~^ ERROR `Fn` traits cannot take lifetime parameters - -use std::ops::Fn as AliasedFn; -fn fd(_: impl AliasedFn<'a>(&'a str) -> bool) {} -//~^ ERROR `Fn` traits cannot take lifetime parameters - -fn fe<F>(_: F) where F: Fn<'a>(&'a str) -> bool {} -//~^ ERROR `Fn` traits cannot take lifetime parameters - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-malformed-lifetime-generics.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-malformed-lifetime-generics.stderr deleted file mode 100644 index e8f6d63b5..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-malformed-lifetime-generics.stderr +++ /dev/null @@ -1,62 +0,0 @@ -error: `Fn` traits cannot take lifetime parameters - --> $DIR/hrtb-malformed-lifetime-generics.rs:4:17 - | -LL | fn fa(_: impl Fn<'a>(&'a str) -> bool) {} - | ^^^^ - | -help: consider using a higher-ranked trait bound instead - | -LL - fn fa(_: impl Fn<'a>(&'a str) -> bool) {} -LL + fn fa(_: impl for<'a> Fn(&'a str) -> bool) {} - | - -error: `Fn` traits cannot take lifetime parameters - --> $DIR/hrtb-malformed-lifetime-generics.rs:7:20 - | -LL | fn fb(_: impl FnMut<'a, 'b>(&'a str, &'b str) -> bool) {} - | ^^^^^^^^ - | -help: consider using a higher-ranked trait bound instead - | -LL - fn fb(_: impl FnMut<'a, 'b>(&'a str, &'b str) -> bool) {} -LL + fn fb(_: impl for<'a, 'b> FnMut(&'a str, &'b str) -> bool) {} - | - -error: `Fn` traits cannot take lifetime parameters - --> $DIR/hrtb-malformed-lifetime-generics.rs:10:41 - | -LL | fn fc(_: impl std::fmt::Display + FnOnce<'a>(&'a str) -> bool + std::fmt::Debug) {} - | ^^^^ - | -help: consider using a higher-ranked trait bound instead - | -LL - fn fc(_: impl std::fmt::Display + FnOnce<'a>(&'a str) -> bool + std::fmt::Debug) {} -LL + fn fc(_: impl std::fmt::Display + for<'a> FnOnce(&'a str) -> bool + std::fmt::Debug) {} - | - -error: `Fn` traits cannot take lifetime parameters - --> $DIR/hrtb-malformed-lifetime-generics.rs:14:24 - | -LL | fn fd(_: impl AliasedFn<'a>(&'a str) -> bool) {} - | ^^^^ - | -help: consider using a higher-ranked trait bound instead - | -LL - fn fd(_: impl AliasedFn<'a>(&'a str) -> bool) {} -LL + fn fd(_: impl for<'a> AliasedFn(&'a str) -> bool) {} - | - -error: `Fn` traits cannot take lifetime parameters - --> $DIR/hrtb-malformed-lifetime-generics.rs:17:27 - | -LL | fn fe<F>(_: F) where F: Fn<'a>(&'a str) -> bool {} - | ^^^^ - | -help: consider using a higher-ranked trait bound instead - | -LL - fn fe<F>(_: F) where F: Fn<'a>(&'a str) -> bool {} -LL + fn fe<F>(_: F) where F: for<'a> Fn(&'a str) -> bool {} - | - -error: aborting due to 5 previous errors - diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-opt-in-copy.rs b/tests/ui/higher-rank-trait-bounds/hrtb-opt-in-copy.rs deleted file mode 100644 index 04519f116..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-opt-in-copy.rs +++ /dev/null @@ -1,28 +0,0 @@ -// run-pass -// Test that we handle binder levels correctly when checking whether a -// type can implement `Copy`. In particular, we had a bug where we failed to -// liberate the late-bound regions from the impl, and thus wound up -// searching for an impl of `for<'tcx> Foo<&'tcx T>`. The impl that -// exists however is `impl<T> Copy for Foo<T>` and the current rules -// did not consider that a match (something I would like to revise in -// a later PR). - -#![allow(dead_code)] - -use std::marker::PhantomData; - -#[derive(Copy, Clone)] -struct Foo<T> { x: T } - -type Ty<'tcx> = &'tcx TyS<'tcx>; - -enum TyS<'tcx> { - Boop(PhantomData<*mut &'tcx ()>) -} - -#[derive(Copy, Clone)] -enum Bar<'tcx> { - Baz(Foo<Ty<'tcx>>) -} - -fn main() { } diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-parse.rs b/tests/ui/higher-rank-trait-bounds/hrtb-parse.rs deleted file mode 100644 index 1fab9758c..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-parse.rs +++ /dev/null @@ -1,36 +0,0 @@ -// run-pass -// Test that we can parse all the various places that a `for` keyword -// can appear representing universal quantification. - -// pretty-expanded FIXME #23616 - -#![allow(unused_variables)] -#![allow(dead_code)] - -trait Get<A,R> { - fn get(&self, arg: A) -> R; -} - -// Parse HRTB with explicit `for` in a where-clause: - -fn foo00<T>(t: T) - where T : for<'a> Get<&'a i32, &'a i32> -{ -} - -fn foo01<T: for<'a> Get<&'a i32, &'a i32>>(t: T) -{ -} - -// Parse HRTB with explicit `for` in various sorts of types: - -fn foo10(t: Box<dyn for<'a> Get<i32, i32>>) { } -fn foo11(t: Box<dyn for<'a> Fn(i32) -> i32>) { } - -fn foo20(t: for<'a> fn(i32) -> i32) { } -fn foo21(t: for<'a> unsafe fn(i32) -> i32) { } -fn foo22(t: for<'a> extern "C" fn(i32) -> i32) { } -fn foo23(t: for<'a> unsafe extern "C" fn(i32) -> i32) { } - -fn main() { -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.polonius.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.polonius.stderr deleted file mode 100644 index a94c80eb3..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.polonius.stderr +++ /dev/null @@ -1,71 +0,0 @@ -warning: function cannot return without recursing - --> $DIR/hrtb-perfect-forwarding.rs:16:1 - | -LL | / fn no_hrtb<'b, T>(mut t: T) -LL | | where -LL | | T: Bar<&'b isize>, -LL | | { -... | -LL | | no_hrtb(&mut t); - | | --------------- recursive call site -LL | | } - | |_^ cannot return without recursing - | - = note: `#[warn(unconditional_recursion)]` on by default - = help: a `loop` may express intention better if this is on purpose - -warning: function cannot return without recursing - --> $DIR/hrtb-perfect-forwarding.rs:25:1 - | -LL | / fn bar_hrtb<T>(mut t: T) -LL | | where -LL | | T: for<'b> Bar<&'b isize>, -LL | | { -... | -LL | | bar_hrtb(&mut t); - | | ---------------- recursive call site -LL | | } - | |_^ cannot return without recursing - | - = help: a `loop` may express intention better if this is on purpose - -warning: function cannot return without recursing - --> $DIR/hrtb-perfect-forwarding.rs:35:1 - | -LL | / fn foo_hrtb_bar_not<'b, T>(mut t: T) -LL | | where -LL | | T: for<'a> Foo<&'a isize> + Bar<&'b isize>, -LL | | { -... | -LL | | foo_hrtb_bar_not(&mut t); - | | ------------------------ recursive call site -LL | | -LL | | -LL | | } - | |_^ cannot return without recursing - | - = help: a `loop` may express intention better if this is on purpose - -error: higher-ranked subtype error - --> $DIR/hrtb-perfect-forwarding.rs:43:5 - | -LL | foo_hrtb_bar_not(&mut t); - | ^^^^^^^^^^^^^^^^^^^^^^^^ - -warning: function cannot return without recursing - --> $DIR/hrtb-perfect-forwarding.rs:48:1 - | -LL | / fn foo_hrtb_bar_hrtb<T>(mut t: T) -LL | | where -LL | | T: for<'a> Foo<&'a isize> + for<'b> Bar<&'b isize>, -LL | | { -LL | | // OK -- now we have `T : for<'b> Bar<&'b isize>`. -LL | | foo_hrtb_bar_hrtb(&mut t); - | | ------------------------- recursive call site -LL | | } - | |_^ cannot return without recursing - | - = help: a `loop` may express intention better if this is on purpose - -error: aborting due to previous error; 4 warnings emitted - diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.rs b/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.rs deleted file mode 100644 index d45fa183c..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.rs +++ /dev/null @@ -1,56 +0,0 @@ -// Test a case where you have an impl of `Foo<X>` for all `X` that -// is being applied to `for<'a> Foo<&'a mut X>`. Issue #19730. - -trait Foo<X> { - fn foo(&mut self, x: X) {} -} - -trait Bar<X> { - fn bar(&mut self, x: X) {} -} - -impl<'a, X, F> Foo<X> for &'a mut F where F: Foo<X> + Bar<X> {} - -impl<'a, X, F> Bar<X> for &'a mut F where F: Bar<X> {} - -fn no_hrtb<'b, T>(mut t: T) //~ WARN function cannot return -where - T: Bar<&'b isize>, -{ - // OK -- `T : Bar<&'b isize>`, and thus the impl above ensures that - // `&mut T : Bar<&'b isize>`. - no_hrtb(&mut t); -} - -fn bar_hrtb<T>(mut t: T) //~ WARN function cannot return -where - T: for<'b> Bar<&'b isize>, -{ - // OK -- `T : for<'b> Bar<&'b isize>`, and thus the impl above - // ensures that `&mut T : for<'b> Bar<&'b isize>`. This is an - // example of a "perfect forwarding" impl. - bar_hrtb(&mut t); -} - -fn foo_hrtb_bar_not<'b, T>(mut t: T) //~ WARN function cannot return -where - T: for<'a> Foo<&'a isize> + Bar<&'b isize>, -{ - // Not OK -- The forwarding impl for `Foo` requires that `Bar` also - // be implemented. Thus to satisfy `&mut T : for<'a> Foo<&'a - // isize>`, we require `T : for<'a> Bar<&'a isize>`, but the where - // clause only specifies `T : Bar<&'b isize>`. - foo_hrtb_bar_not(&mut t); - //~^ ERROR implementation of `Bar` is not general enough - //~^^ ERROR lifetime may not live long enough -} - -fn foo_hrtb_bar_hrtb<T>(mut t: T) //~ WARN function cannot return -where - T: for<'a> Foo<&'a isize> + for<'b> Bar<&'b isize>, -{ - // OK -- now we have `T : for<'b> Bar<&'b isize>`. - foo_hrtb_bar_hrtb(&mut t); -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.stderr deleted file mode 100644 index 727b9e6be..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-perfect-forwarding.stderr +++ /dev/null @@ -1,79 +0,0 @@ -warning: function cannot return without recursing - --> $DIR/hrtb-perfect-forwarding.rs:16:1 - | -LL | / fn no_hrtb<'b, T>(mut t: T) -LL | | where -LL | | T: Bar<&'b isize>, - | |______________________^ cannot return without recursing -... -LL | no_hrtb(&mut t); - | --------------- recursive call site - | - = help: a `loop` may express intention better if this is on purpose - = note: `#[warn(unconditional_recursion)]` on by default - -warning: function cannot return without recursing - --> $DIR/hrtb-perfect-forwarding.rs:25:1 - | -LL | / fn bar_hrtb<T>(mut t: T) -LL | | where -LL | | T: for<'b> Bar<&'b isize>, - | |______________________________^ cannot return without recursing -... -LL | bar_hrtb(&mut t); - | ---------------- recursive call site - | - = help: a `loop` may express intention better if this is on purpose - -warning: function cannot return without recursing - --> $DIR/hrtb-perfect-forwarding.rs:35:1 - | -LL | / fn foo_hrtb_bar_not<'b, T>(mut t: T) -LL | | where -LL | | T: for<'a> Foo<&'a isize> + Bar<&'b isize>, - | |_______________________________________________^ cannot return without recursing -... -LL | foo_hrtb_bar_not(&mut t); - | ------------------------ recursive call site - | - = help: a `loop` may express intention better if this is on purpose - -error: lifetime may not live long enough - --> $DIR/hrtb-perfect-forwarding.rs:43:5 - | -LL | fn foo_hrtb_bar_not<'b, T>(mut t: T) - | -- lifetime `'b` defined here -... -LL | foo_hrtb_bar_not(&mut t); - | ^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'b` must outlive `'static` - | -note: due to current limitations in the borrow checker, this implies a `'static` lifetime - --> $DIR/hrtb-perfect-forwarding.rs:37:8 - | -LL | T: for<'a> Foo<&'a isize> + Bar<&'b isize>, - | ^^^^^^^^^^^^^^^^^^^^^^ - -error: implementation of `Bar` is not general enough - --> $DIR/hrtb-perfect-forwarding.rs:43:5 - | -LL | foo_hrtb_bar_not(&mut t); - | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Bar` is not general enough - | - = note: `T` must implement `Bar<&'0 isize>`, for any lifetime `'0`... - = note: ...but it actually implements `Bar<&'1 isize>`, for some specific lifetime `'1` - -warning: function cannot return without recursing - --> $DIR/hrtb-perfect-forwarding.rs:48:1 - | -LL | / fn foo_hrtb_bar_hrtb<T>(mut t: T) -LL | | where -LL | | T: for<'a> Foo<&'a isize> + for<'b> Bar<&'b isize>, - | |_______________________________________________________^ cannot return without recursing -... -LL | foo_hrtb_bar_hrtb(&mut t); - | ------------------------- recursive call site - | - = help: a `loop` may express intention better if this is on purpose - -error: aborting due to 2 previous errors; 4 warnings emitted - diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-precedence-of-plus-where-clause.rs b/tests/ui/higher-rank-trait-bounds/hrtb-precedence-of-plus-where-clause.rs deleted file mode 100644 index 42247798f..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-precedence-of-plus-where-clause.rs +++ /dev/null @@ -1,25 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![allow(unused_variables)] -// pretty-expanded FIXME #23616 - -// Test that `F : Fn(isize) -> isize + Send` is interpreted as two -// distinct bounds on `F`. - -fn foo1<F>(f: F) - where F : FnOnce(isize) -> isize + Send -{ - bar(f); -} - -fn foo2<F>(f: F) - where F : FnOnce(isize) -> isize + Send -{ - baz(f); -} - -fn bar<F:Send>(f: F) { } - -fn baz<F:FnOnce(isize) -> isize>(f: F) { } - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-precedence-of-plus.rs b/tests/ui/higher-rank-trait-bounds/hrtb-precedence-of-plus.rs deleted file mode 100644 index 6834c392d..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-precedence-of-plus.rs +++ /dev/null @@ -1,13 +0,0 @@ -// run-pass -#![allow(dead_code)] -// pretty-expanded FIXME #23616 - -// Test that `Fn(isize) -> isize + 'static` parses as `(Fn(isize) -> isize) + -// 'static` and not `Fn(isize) -> (isize + 'static)`. The latter would -// cause a compilation error. Issue #18772. - -fn adder(y: isize) -> Box<dyn Fn(isize) -> isize + 'static> { - Box::new(move |x| y + x) -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-resolve-lifetime.rs b/tests/ui/higher-rank-trait-bounds/hrtb-resolve-lifetime.rs deleted file mode 100644 index b97fdf4df..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-resolve-lifetime.rs +++ /dev/null @@ -1,14 +0,0 @@ -// run-pass -#![allow(dead_code)] -// A basic test of using a higher-ranked trait bound. - -// pretty-expanded FIXME #23616 - -trait FnLike<A,R> { - fn call(&self, arg: A) -> R; -} - -type FnObject<'b> = dyn for<'a> FnLike<&'a isize, &'a isize> + 'b; - -fn main() { -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-trait-object-paren-notation.rs b/tests/ui/higher-rank-trait-bounds/hrtb-trait-object-paren-notation.rs deleted file mode 100644 index d8c726cdd..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-trait-object-paren-notation.rs +++ /dev/null @@ -1,26 +0,0 @@ -// run-pass -// A basic test of using a higher-ranked trait bound. - -trait FnLike<A,R> { - fn call(&self, arg: A) -> R; -} - -type FnObject<'b> = dyn for<'a> FnLike<(&'a i32,), &'a i32> + 'b; - -struct Identity; - -impl<'a, T> FnLike<(&'a T,), &'a T> for Identity { - fn call(&self, (arg,): (&'a T,)) -> &'a T { - arg - } -} - -fn call_repeatedly(f: &FnObject) { - let x = 3; - let y = f.call((&x,)); - assert_eq!(3, *y); -} - -fn main() { - call_repeatedly(&Identity); -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-trait-object-passed-to-closure.rs b/tests/ui/higher-rank-trait-bounds/hrtb-trait-object-passed-to-closure.rs deleted file mode 100644 index 41ebb3f5a..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-trait-object-passed-to-closure.rs +++ /dev/null @@ -1,25 +0,0 @@ -// run-pass -#![allow(dead_code)] -// Test that `&PrinterSupport`, which is really short for `&'a -// PrinterSupport<'b>`, gets properly expanded when it appears in a -// closure type. This used to result in messed up De Bruijn indices. - -// pretty-expanded FIXME #23616 - -trait PrinterSupport<'ast> { - fn ast_map(&self) -> Option<&'ast usize> { None } -} - -struct NoAnn<'ast> { - f: Option<&'ast usize> -} - -impl<'ast> PrinterSupport<'ast> for NoAnn<'ast> { -} - -fn foo<'ast, G>(f: Option<&'ast usize>, g: G) where G: FnOnce(&dyn PrinterSupport) { - let annotation = NoAnn { f: f }; - g(&annotation) -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-type-outlives.rs b/tests/ui/higher-rank-trait-bounds/hrtb-type-outlives.rs deleted file mode 100644 index 88d396101..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-type-outlives.rs +++ /dev/null @@ -1,46 +0,0 @@ -// run-pass -#![allow(dead_code)] -#![allow(unused_variables)] -// Test what happens when a HR obligation is applied to an impl with -// "outlives" bounds. Currently we're pretty conservative here; this -// will probably improve in time. - -trait Foo<X> { - fn foo(&self, x: X) { } -} - -fn want_foo<T>() - where T : for<'a> Foo<&'a isize> -{ -} - -// Expressed as a where clause - -struct SomeStruct<X> { - x: X -} - -impl<'a,X> Foo<&'a isize> for SomeStruct<X> - where X : 'a -{ -} - -fn one() { - want_foo::<SomeStruct<usize>>(); -} - -// Expressed as shorthand - -struct AnotherStruct<X> { - x: X -} - -impl<'a,X:'a> Foo<&'a isize> for AnotherStruct<X> -{ -} - -fn two() { - want_foo::<AnotherStruct<usize>>(); -} - -fn main() { } diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-unboxed-closure-trait.rs b/tests/ui/higher-rank-trait-bounds/hrtb-unboxed-closure-trait.rs deleted file mode 100644 index a4a8a5ac6..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-unboxed-closure-trait.rs +++ /dev/null @@ -1,11 +0,0 @@ -// run-pass -// Test HRTB used with the `Fn` trait. - -fn foo<F:Fn(&isize)>(f: F) { - let x = 22; - f(&x); -} - -fn main() { - foo(|x: &isize| println!("{}", *x)); -} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-wrong-kind.rs b/tests/ui/higher-rank-trait-bounds/hrtb-wrong-kind.rs deleted file mode 100644 index 1a9bb2523..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-wrong-kind.rs +++ /dev/null @@ -1,7 +0,0 @@ -fn a() where for<T> T: Copy {} -//~^ ERROR only lifetime parameters can be used in this context - -fn b() where for<const C: usize> [(); C]: Copy {} -//~^ ERROR only lifetime parameters can be used in this context - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/hrtb-wrong-kind.stderr b/tests/ui/higher-rank-trait-bounds/hrtb-wrong-kind.stderr deleted file mode 100644 index 765ea9f78..000000000 --- a/tests/ui/higher-rank-trait-bounds/hrtb-wrong-kind.stderr +++ /dev/null @@ -1,21 +0,0 @@ -error[E0658]: only lifetime parameters can be used in this context - --> $DIR/hrtb-wrong-kind.rs:1:18 - | -LL | fn a() where for<T> T: Copy {} - | ^ - | - = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information - = help: add `#![feature(non_lifetime_binders)]` to the crate attributes to enable - -error[E0658]: only lifetime parameters can be used in this context - --> $DIR/hrtb-wrong-kind.rs:4:24 - | -LL | fn b() where for<const C: usize> [(); C]: Copy {} - | ^ - | - = note: see issue #108185 <https://github.com/rust-lang/rust/issues/108185> for more information - = help: add `#![feature(non_lifetime_binders)]` to the crate attributes to enable - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0658`. diff --git a/tests/ui/higher-rank-trait-bounds/issue-100689.rs b/tests/ui/higher-rank-trait-bounds/issue-100689.rs deleted file mode 100644 index 2db7f8a35..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-100689.rs +++ /dev/null @@ -1,29 +0,0 @@ -// check-pass - -struct Foo<'a> { - foo: &'a mut usize, -} - -trait Bar<'a> { - type FooRef<'b> - where - 'a: 'b; - fn uwu(foo: Foo<'a>, f: impl for<'b> FnMut(Self::FooRef<'b>)); -} -impl<'a> Bar<'a> for () { - type FooRef<'b> - = - &'b Foo<'a> - where - 'a : 'b, - ; - - fn uwu( - foo: Foo<'a>, - mut f: impl for<'b> FnMut(&'b Foo<'a>), //relevant part - ) { - f(&foo); - } -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/issue-102899.rs b/tests/ui/higher-rank-trait-bounds/issue-102899.rs deleted file mode 100644 index 952b81584..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-102899.rs +++ /dev/null @@ -1,32 +0,0 @@ -// check-pass - -pub trait BufferTrait<'buffer> { - type Subset<'channel> - where - 'buffer: 'channel; - - fn for_each_subset<F>(&self, f: F) - where - F: for<'channel> Fn(Self::Subset<'channel>); -} - -pub struct SomeBuffer<'buffer> { - samples: &'buffer [()], -} - -impl<'buffer> BufferTrait<'buffer> for SomeBuffer<'buffer> { - type Subset<'subset> = Subset<'subset> where 'buffer: 'subset; - - fn for_each_subset<F>(&self, _f: F) - where - F: for<'subset> Fn(Subset<'subset>), - { - todo!() - } -} - -pub struct Subset<'subset> { - buffer: &'subset [()], -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/issue-30786.rs b/tests/ui/higher-rank-trait-bounds/issue-30786.rs deleted file mode 100644 index 4a6399c8f..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-30786.rs +++ /dev/null @@ -1,136 +0,0 @@ -// normalize-stderr-test: "long-type-\d+" -> "long-type-hash" - -// rust-lang/rust#30786: the use of `for<'b> &'b mut A: Stream<Item=T` -// should act as assertion that item does not borrow from its stream; -// but an earlier buggy rustc allowed `.map(|x: &_| x)` which does -// have such an item. -// -// This tests double-checks that we do not allow such behavior to leak -// through again. - -pub trait Stream { - type Item; - fn next(self) -> Option<Self::Item>; -} - -// Example stream -pub struct Repeat(u64); - -impl<'a> Stream for &'a mut Repeat { - type Item = &'a u64; - fn next(self) -> Option<Self::Item> { - Some(&self.0) - } -} - -pub struct Map<S, F> { - stream: S, - func: F, -} - -impl<'a, A, F, T> Stream for &'a mut Map<A, F> -where - &'a mut A: Stream, - F: FnMut(<&'a mut A as Stream>::Item) -> T, -{ - type Item = T; - fn next(self) -> Option<T> { - match self.stream.next() { - Some(item) => Some((self.func)(item)), - None => None, - } - } -} - -pub struct Filter<S, F> { - stream: S, - func: F, -} - -impl<'a, A, F, T> Stream for &'a mut Filter<A, F> -where - for<'b> &'b mut A: Stream<Item = T>, // <---- BAD - F: FnMut(&T) -> bool, -{ - type Item = <&'a mut A as Stream>::Item; - fn next(self) -> Option<Self::Item> { - while let Some(item) = self.stream.next() { - if (self.func)(&item) { - return Some(item); - } - } - None - } -} - -pub trait StreamExt -where - for<'b> &'b mut Self: Stream, -{ - fn mapx<F>(self, func: F) -> Map<Self, F> - where - Self: Sized, - for<'a> &'a mut Map<Self, F>: Stream, - { - Map { func: func, stream: self } - } - - fn filterx<F>(self, func: F) -> Filter<Self, F> - where - Self: Sized, - for<'a> &'a mut Filter<Self, F>: Stream, - { - Filter { func: func, stream: self } - } - - fn countx(mut self) -> usize - where - Self: Sized, - { - let mut count = 0; - while let Some(_) = self.next() { - count += 1; - } - count - } -} - -impl<T> StreamExt for T where for<'a> &'a mut T: Stream {} - -fn identity<T>(x: &T) -> &T { - x -} - -fn variant1() { - let source = Repeat(10); - - // Here, the call to `mapx` returns a type `T` to which `StreamExt` - // is not applicable, because `for<'b> &'b mut T: Stream`) doesn't hold. - // - // More concretely, the type `T` is `Map<Repeat, Closure>`, and - // the where clause doesn't hold because the signature of the - // closure gets inferred to a signature like `|&'_ Stream| -> &'_` - // for some specific `'_`, rather than a more generic - // signature. - // - // Why *exactly* we opt for this signature is a bit unclear to me, - // we deduce it somehow from a reuqirement that `Map: Stream` I - // guess. - let map = source.mapx(|x: &_| x); - let filter = map.filterx(|x: &_| true); - //~^ ERROR the method -} - -fn variant2() { - let source = Repeat(10); - - // Here, we use a function, which is not subject to the vagaries - // of closure signature inference. In this case, we get the error - // on `countx` as, I think, the test originally expected. - let map = source.mapx(identity); - let filter = map.filterx(|x: &_| true); - let count = filter.countx(); - //~^ ERROR the method -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/issue-30786.stderr b/tests/ui/higher-rank-trait-bounds/issue-30786.stderr deleted file mode 100644 index 6ec34d11a..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-30786.stderr +++ /dev/null @@ -1,46 +0,0 @@ -error[E0599]: the method `filterx` exists for struct `Map<Repeat, [closure@issue-30786.rs:119:27]>`, but its trait bounds were not satisfied - --> $DIR/issue-30786.rs:120:22 - | -LL | pub struct Map<S, F> { - | -------------------- - | | - | method `filterx` not found for this struct - | doesn't satisfy `_: StreamExt` -... -LL | let filter = map.filterx(|x: &_| true); - | ^^^^^^^ method cannot be called on `Map<Repeat, [closure@issue-30786.rs:119:27]>` due to unsatisfied trait bounds - | -note: the following trait bounds were not satisfied: - `&'a mut &Map<Repeat, [closure@$DIR/issue-30786.rs:119:27: 119:34]>: Stream` - `&'a mut &mut Map<Repeat, [closure@$DIR/issue-30786.rs:119:27: 119:34]>: Stream` - `&'a mut Map<Repeat, [closure@$DIR/issue-30786.rs:119:27: 119:34]>: Stream` - --> $DIR/issue-30786.rs:98:50 - | -LL | impl<T> StreamExt for T where for<'a> &'a mut T: Stream {} - | --------- - ^^^^^^ unsatisfied trait bound introduced here - -error[E0599]: the method `countx` exists for struct `Filter<Map<Repeat, fn(&u64) -> &u64 {identity::<u64>}>, [closure@issue-30786.rs:131:30]>`, but its trait bounds were not satisfied - --> $DIR/issue-30786.rs:132:24 - | -LL | pub struct Filter<S, F> { - | ----------------------- - | | - | method `countx` not found for this struct - | doesn't satisfy `_: StreamExt` -... -LL | let count = filter.countx(); - | ^^^^^^ method cannot be called due to unsatisfied trait bounds - | - = note: the full type name has been written to '$TEST_BUILD_DIR/higher-rank-trait-bounds/issue-30786/issue-30786.long-type-hash.txt' -note: the following trait bounds were not satisfied: - `&'a mut &Filter<Map<Repeat, for<'a> fn(&'a u64) -> &'a u64 {identity::<u64>}>, [closure@$DIR/issue-30786.rs:131:30: 131:37]>: Stream` - `&'a mut &mut Filter<Map<Repeat, for<'a> fn(&'a u64) -> &'a u64 {identity::<u64>}>, [closure@$DIR/issue-30786.rs:131:30: 131:37]>: Stream` - `&'a mut Filter<Map<Repeat, for<'a> fn(&'a u64) -> &'a u64 {identity::<u64>}>, [closure@$DIR/issue-30786.rs:131:30: 131:37]>: Stream` - --> $DIR/issue-30786.rs:98:50 - | -LL | impl<T> StreamExt for T where for<'a> &'a mut T: Stream {} - | --------- - ^^^^^^ unsatisfied trait bound introduced here - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0599`. diff --git a/tests/ui/higher-rank-trait-bounds/issue-36139-normalize-closure-sig.rs b/tests/ui/higher-rank-trait-bounds/issue-36139-normalize-closure-sig.rs deleted file mode 100644 index 2d49151ff..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-36139-normalize-closure-sig.rs +++ /dev/null @@ -1,19 +0,0 @@ -// run-pass -// Previously the closure's argument would be inferred to -// <S as ITrait<'a>>::Item, causing an error in MIR type -// checking - -trait ITrait<'a> {type Item;} - -struct S {} - -impl<'a> ITrait<'a> for S { type Item = &'a mut usize; } - -fn m<T, I, F>(_: F) - where I: for<'a> ITrait<'a>, - F: for<'a> FnMut(<I as ITrait<'a>>::Item) { } - - -fn main() { - m::<usize,S,_>(|x| { *x += 1; }); -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-39292.rs b/tests/ui/higher-rank-trait-bounds/issue-39292.rs deleted file mode 100644 index 968cf0891..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-39292.rs +++ /dev/null @@ -1,17 +0,0 @@ -// run-pass -// Regression test for issue #39292. The object vtable was being -// incorrectly left with a null pointer. - -trait Foo<T> { - fn print<'a>(&'a self) where T: 'a { println!("foo"); } -} - -impl<'a> Foo<&'a ()> for () { } - -trait Bar: for<'a> Foo<&'a ()> { } - -impl Bar for () {} - -fn main() { - (&() as &dyn Bar).print(); // Segfault -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-42114.rs b/tests/ui/higher-rank-trait-bounds/issue-42114.rs deleted file mode 100644 index 01515fdc9..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-42114.rs +++ /dev/null @@ -1,20 +0,0 @@ -// check-pass - -fn lifetime<'a>() -where - &'a (): 'a, -{ - /* do nothing */ -} - -fn doesnt_work() -where - for<'a> &'a (): 'a, -{ - /* do nothing */ -} - -fn main() { - lifetime(); - doesnt_work(); -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-43623.rs b/tests/ui/higher-rank-trait-bounds/issue-43623.rs deleted file mode 100644 index cedcf7c36..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-43623.rs +++ /dev/null @@ -1,21 +0,0 @@ -// check-pass - -pub trait Trait<'a> { - type Assoc; -} - -pub struct Type; - -impl<'a> Trait<'a> for Type { - type Assoc = (); -} - -pub fn break_me<T, F>(f: F) -where - T: for<'b> Trait<'b>, - F: for<'b> FnMut(<T as Trait<'b>>::Assoc), -{ - break_me::<Type, fn(_)>; -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/issue-46989.rs b/tests/ui/higher-rank-trait-bounds/issue-46989.rs deleted file mode 100644 index 4a09f4be1..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-46989.rs +++ /dev/null @@ -1,40 +0,0 @@ -// Regression test for #46989: -// -// In the move to universes, this test started passing. -// It is not necessarily WRONG to do so, but it was a bit -// surprising. The reason that it passed is that when we were -// asked to prove that -// -// for<'a> fn(&'a i32): Foo -// -// we were able to use the impl below to prove -// -// fn(&'empty i32): Foo -// -// and then we were able to prove that -// -// fn(&'empty i32) = for<'a> fn(&'a i32) -// -// This last fact is somewhat surprising, but essentially "falls out" -// from handling variance correctly. In particular, consider the subtyping -// relations. First: -// -// fn(&'empty i32) <: for<'a> fn(&'a i32) -// -// This holds because -- intuitively -- a fn that takes a reference but doesn't use -// it can be given a reference with any lifetime. Similarly, the opposite direction: -// -// for<'a> fn(&'a i32) <: fn(&'empty i32) -// -// holds because 'a can be instantiated to 'empty. - -trait Foo {} - -impl<A> Foo for fn(A) {} - -fn assert_foo<T: Foo>() {} - -fn main() { - assert_foo::<fn(&i32)>(); - //~^ ERROR implementation of `Foo` is not general enough -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-46989.stderr b/tests/ui/higher-rank-trait-bounds/issue-46989.stderr deleted file mode 100644 index 3f874220a..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-46989.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error: implementation of `Foo` is not general enough - --> $DIR/issue-46989.rs:38:5 - | -LL | assert_foo::<fn(&i32)>(); - | ^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Foo` is not general enough - | - = note: `Foo` would have to be implemented for the type `for<'a> fn(&'a i32)` - = note: ...but `Foo` is actually implemented for the type `fn(&'0 i32)`, for some specific lifetime `'0` - -error: aborting due to previous error - diff --git a/tests/ui/higher-rank-trait-bounds/issue-57639.rs b/tests/ui/higher-rank-trait-bounds/issue-57639.rs deleted file mode 100644 index 392e7233b..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-57639.rs +++ /dev/null @@ -1,29 +0,0 @@ -// Regression test for #57639: -// -// In the move to universes, this test stopped working. The problem -// was that when the trait solver was asked to prove `for<'a> T::Item: -// Foo<'a>` as part of WF checking, it wound up "eagerly committing" -// to the where clause, which says that `T::Item: Foo<'a>`, but it -// should instead have been using the bound found in the trait -// declaration. Pre-universe, this used to work out ok because we got -// "eager errors" due to the leak check. -// -// See [this comment on GitHub][c] for more details. -// -// check-pass -// -// [c]: https://github.com/rust-lang/rust/issues/57639#issuecomment-455685861 - -trait Foo<'a> {} - -trait Bar { - type Item: for<'a> Foo<'a>; -} - -fn foo<'a, T>(_: T) -where - T: Bar, - T::Item: Foo<'a>, -{} - -fn main() { } diff --git a/tests/ui/higher-rank-trait-bounds/issue-58451.rs b/tests/ui/higher-rank-trait-bounds/issue-58451.rs deleted file mode 100644 index 6006a108c..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-58451.rs +++ /dev/null @@ -1,13 +0,0 @@ -// Regression test for #58451: -// -// Error reporting here encountered an ICE in the shift to universes. - -fn f<I>(i: I) -where - I: IntoIterator, - I::Item: for<'a> Into<&'a ()>, -{} - -fn main() { - f(&[f()]); //~ ERROR function takes 1 argument -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-58451.stderr b/tests/ui/higher-rank-trait-bounds/issue-58451.stderr deleted file mode 100644 index 0f051be21..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-58451.stderr +++ /dev/null @@ -1,19 +0,0 @@ -error[E0061]: this function takes 1 argument but 0 arguments were supplied - --> $DIR/issue-58451.rs:12:9 - | -LL | f(&[f()]); - | ^-- an argument is missing - | -note: function defined here - --> $DIR/issue-58451.rs:5:4 - | -LL | fn f<I>(i: I) - | ^ ---- -help: provide the argument - | -LL | f(&[f(/* i */)]); - | ~~~~~~~~~ - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0061`. diff --git a/tests/ui/higher-rank-trait-bounds/issue-59311.rs b/tests/ui/higher-rank-trait-bounds/issue-59311.rs deleted file mode 100644 index 3ad548450..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-59311.rs +++ /dev/null @@ -1,22 +0,0 @@ -// Regression test for #59311. The test is taken from -// rust-lang/rust/issues/71546#issuecomment-620638437 -// as they seem to have the same cause. - -// FIXME: It's not clear that this code ought to report -// an error, but the regression test is here to ensure -// that it does not ICE. See discussion on #74889 for details. - -pub trait T { - fn t<F: Fn()>(&self, _: F) {} -} - -pub fn crash<V>(v: &V) -where - for<'a> &'a V: T + 'static, -{ - v.t(|| {}); - //~^ ERROR: higher-ranked lifetime error - //~| ERROR: higher-ranked lifetime error -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/issue-59311.stderr b/tests/ui/higher-rank-trait-bounds/issue-59311.stderr deleted file mode 100644 index c01ab8e34..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-59311.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error: higher-ranked lifetime error - --> $DIR/issue-59311.rs:17:5 - | -LL | v.t(|| {}); - | ^^^^^^^^^^ - | - = note: could not prove `[closure@$DIR/issue-59311.rs:17:9: 17:11] well-formed` - -error: higher-ranked lifetime error - --> $DIR/issue-59311.rs:17:9 - | -LL | v.t(|| {}); - | ^^^^^ - | - = note: could not prove `for<'a> &'a V: 'static` - -error: aborting due to 2 previous errors - diff --git a/tests/ui/higher-rank-trait-bounds/issue-60283.rs b/tests/ui/higher-rank-trait-bounds/issue-60283.rs deleted file mode 100644 index 05315b3f9..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-60283.rs +++ /dev/null @@ -1,20 +0,0 @@ -// check-pass - -pub trait Trait<'a> { - type Item; -} - -impl<'a> Trait<'a> for () { - type Item = (); -} - -pub fn foo<T, F>(_: T, _: F) -where - T: for<'a> Trait<'a>, - F: for<'a> FnMut(<T as Trait<'a>>::Item), -{ -} - -fn main() { - foo((), drop) -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.rs b/tests/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.rs deleted file mode 100644 index e70f6fc34..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.rs +++ /dev/null @@ -1,54 +0,0 @@ -trait T0<'a, A> { - type O; -} - -struct L<T> { - f: T, -} - -// explicitly named variants of what one would normally denote by the -// unit type `()`. Why do this? So that we can differentiate them in -// the diagnostic output. -struct Unit1; -struct Unit2; -struct Unit3; -struct Unit4; - -impl<'a, A, T> T0<'a, A> for L<T> -where - T: FnMut(A) -> Unit3, -{ - type O = T::Output; -} - -trait T1: for<'r> Ty<'r> { - fn m<'a, B: Ty<'a>, F>(&self, f: F) -> Unit1 - where - F: for<'r> T0<'r, (<Self as Ty<'r>>::V,), O = <B as Ty<'r>>::V>, - { - unimplemented!(); - } -} - -trait Ty<'a> { - type V; -} - -fn main() { - let v = Unit2.m( - L { - //~^ ERROR to be a closure that returns `Unit3`, but it returns `Unit4` - //~| ERROR type mismatch - f: |x| { - drop(x); - Unit4 - }, - }, - ); -} - -impl<'a> Ty<'a> for Unit2 { - type V = &'a u8; -} - -impl T1 for Unit2 {} diff --git a/tests/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.stderr b/tests/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.stderr deleted file mode 100644 index 4d470ae70..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.stderr +++ /dev/null @@ -1,66 +0,0 @@ -error[E0271]: type mismatch resolving `<L<[closure@issue-62203-hrtb-ice.rs:42:16]> as T0<'r, (&u8,)>>::O == <_ as Ty<'r>>::V` - --> $DIR/issue-62203-hrtb-ice.rs:39:9 - | -LL | let v = Unit2.m( - | - required by a bound introduced by this call -LL | / L { -LL | | -LL | | -LL | | f: |x| { -... | -LL | | }, -LL | | }, - | |_________^ type mismatch resolving `<L<[closure@issue-62203-hrtb-ice.rs:42:16]> as T0<'r, (&u8,)>>::O == <_ as Ty<'r>>::V` - | -note: expected this to be `<_ as Ty<'_>>::V` - --> $DIR/issue-62203-hrtb-ice.rs:21:14 - | -LL | type O = T::Output; - | ^^^^^^^^^ - = note: expected associated type `<_ as Ty<'_>>::V` - found struct `Unit4` - = help: consider constraining the associated type `<_ as Ty<'_>>::V` to `Unit4` or calling a method that returns `<_ as Ty<'_>>::V` - = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html -note: required by a bound in `T1::m` - --> $DIR/issue-62203-hrtb-ice.rs:27:51 - | -LL | fn m<'a, B: Ty<'a>, F>(&self, f: F) -> Unit1 - | - required by a bound in this associated function -LL | where -LL | F: for<'r> T0<'r, (<Self as Ty<'r>>::V,), O = <B as Ty<'r>>::V>, - | ^^^^^^^^^^^^^^^^^^^^ required by this bound in `T1::m` - -error[E0271]: expected `[closure@issue-62203-hrtb-ice.rs:42:16]` to be a closure that returns `Unit3`, but it returns `Unit4` - --> $DIR/issue-62203-hrtb-ice.rs:39:9 - | -LL | let v = Unit2.m( - | - required by a bound introduced by this call -LL | / L { -LL | | -LL | | -LL | | f: |x| { -... | -LL | | }, -LL | | }, - | |_________^ expected `Unit3`, found `Unit4` - | -note: required for `L<[closure@$DIR/issue-62203-hrtb-ice.rs:42:16: 42:19]>` to implement `for<'r> T0<'r, (&'r u8,)>` - --> $DIR/issue-62203-hrtb-ice.rs:17:16 - | -LL | impl<'a, A, T> T0<'a, A> for L<T> - | ^^^^^^^^^ ^^^^ -LL | where -LL | T: FnMut(A) -> Unit3, - | ----- unsatisfied trait bound introduced here -note: required by a bound in `T1::m` - --> $DIR/issue-62203-hrtb-ice.rs:27:12 - | -LL | fn m<'a, B: Ty<'a>, F>(&self, f: F) -> Unit1 - | - required by a bound in this associated function -LL | where -LL | F: for<'r> T0<'r, (<Self as Ty<'r>>::V,), O = <B as Ty<'r>>::V>, - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `T1::m` - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0271`. diff --git a/tests/ui/higher-rank-trait-bounds/issue-88446.rs b/tests/ui/higher-rank-trait-bounds/issue-88446.rs deleted file mode 100644 index 571b85317..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-88446.rs +++ /dev/null @@ -1,35 +0,0 @@ -// check-pass - -trait Yokeable<'a> { - type Output: 'a; -} -impl<'a> Yokeable<'a> for () { - type Output = (); -} - -trait DataMarker<'data> { - type Yokeable: for<'a> Yokeable<'a>; -} -impl<'data> DataMarker<'data> for () { - type Yokeable = (); -} - -struct DataPayload<'data, M>(&'data M); - -impl DataPayload<'static, ()> { - pub fn map_project_with_capture<M2, T>( - _: for<'a> fn( - capture: T, - std::marker::PhantomData<&'a ()>, - ) -> <M2::Yokeable as Yokeable<'a>>::Output, - ) -> DataPayload<'static, M2> - where - M2: DataMarker<'static>, - { - todo!() - } -} - -fn main() { - let _: DataPayload<()> = DataPayload::<()>::map_project_with_capture::<_, &()>(|_, _| todo!()); -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-88586-hr-self-outlives-in-trait-def.rs b/tests/ui/higher-rank-trait-bounds/issue-88586-hr-self-outlives-in-trait-def.rs deleted file mode 100644 index 92b7c5deb..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-88586-hr-self-outlives-in-trait-def.rs +++ /dev/null @@ -1,13 +0,0 @@ -// Regression test for #88586: a higher-ranked outlives bound on Self in a trait -// definition caused an ICE when debug_assertions were enabled. -// -// Made to pass as part of fixing #98095. -// -// check-pass - -trait A where - for<'a> Self: 'a, -{ -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/issue-90177.rs b/tests/ui/higher-rank-trait-bounds/issue-90177.rs deleted file mode 100644 index b151a9d3a..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-90177.rs +++ /dev/null @@ -1,32 +0,0 @@ -// check-pass - -trait Base<'f> { - type Assoc; - - fn do_something(&self); -} - -trait ForAnyLifetime: for<'f> Base<'f> {} - -impl<T> ForAnyLifetime for T where T: for<'f> Base<'f> {} - -trait CanBeDynamic: ForAnyLifetime + for<'f> Base<'f, Assoc = ()> {} - -fn foo(a: &dyn CanBeDynamic) { - a.do_something(); -} - -struct S; - -impl<'a> Base<'a> for S { - type Assoc = (); - - fn do_something(&self) {} -} - -impl CanBeDynamic for S {} - -fn main() { - let s = S; - foo(&s); -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-95034.rs b/tests/ui/higher-rank-trait-bounds/issue-95034.rs deleted file mode 100644 index af4946a18..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-95034.rs +++ /dev/null @@ -1,80 +0,0 @@ -// check-pass -// compile-flags: --edition=2021 --crate-type=lib - -use std::{ - future::Future, - marker::PhantomData, - pin::Pin, - task::{Context, Poll}, -}; - -mod object { - use super::*; - - pub trait Object<'a> { - type Error; - type Future: Future<Output = Self>; - fn create() -> Self::Future; - } - - impl<'a> Object<'a> for u8 { - type Error = (); - type Future = Pin<Box<dyn Future<Output = Self>>>; - fn create() -> Self::Future { - unimplemented!() - } - } - - impl<'a, E, A: Object<'a, Error = E>> Object<'a> for (A,) { - type Error = (); - type Future = CustomFut<'a, E, A>; - fn create() -> Self::Future { - unimplemented!() - } - } - - pub struct CustomFut<'f, E, A: Object<'f, Error = E>> { - ph: PhantomData<(A::Future,)>, - } - - impl<'f, E, A: Object<'f, Error = E>> Future for CustomFut<'f, E, A> { - type Output = (A,); - fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> { - unimplemented!() - } - } -} - -mod async_fn { - use super::*; - - pub trait AsyncFn { - type Future: Future<Output = ()>; - fn call(&self) -> Self::Future; - } - - impl<F, Fut> AsyncFn for F - where - F: Fn() -> Fut, - Fut: Future<Output = ()>, - { - type Future = Fut; - fn call(&self) -> Self::Future { - (self)() - } - } -} - -pub async fn test() { - use self::{async_fn::AsyncFn, object::Object}; - - async fn create<T: Object<'static>>() { - T::create().await; - } - - async fn call_async_fn(inner: impl AsyncFn) { - inner.call().await; - } - - call_async_fn(create::<(u8,)>).await; -} diff --git a/tests/ui/higher-rank-trait-bounds/issue-95230.new.stderr b/tests/ui/higher-rank-trait-bounds/issue-95230.new.stderr deleted file mode 100644 index d4bc5b672..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-95230.new.stderr +++ /dev/null @@ -1,19 +0,0 @@ -error[E0275]: overflow evaluating the requirement `for<'a> &'a mut Bar well-formed` - --> $DIR/issue-95230.rs:9:13 - | -LL | for<'a> &'a mut Self:; - | ^^^^^^^^^^^^ - | - = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_95230`) -note: required by a bound in `Bar` - --> $DIR/issue-95230.rs:9:13 - | -LL | pub struct Bar - | --- required by a bound in this struct -LL | where -LL | for<'a> &'a mut Self:; - | ^^^^^^^^^^^^ required by this bound in `Bar` - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0275`. diff --git a/tests/ui/higher-rank-trait-bounds/issue-95230.rs b/tests/ui/higher-rank-trait-bounds/issue-95230.rs deleted file mode 100644 index 769b6a925..000000000 --- a/tests/ui/higher-rank-trait-bounds/issue-95230.rs +++ /dev/null @@ -1,11 +0,0 @@ -// revisions: old new -//[new] compile-flags: -Ztrait-solver=next -//[old] check-pass -//[new] known-bug: #109764 - - -pub struct Bar -where - for<'a> &'a mut Self:; - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-44005.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-44005.rs deleted file mode 100644 index f255eac0c..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-44005.rs +++ /dev/null @@ -1,31 +0,0 @@ -// check-pass - -pub trait Foo<'a> { - type Bar; - fn foo(&'a self) -> Self::Bar; -} - -impl<'a, 'b, T: 'a> Foo<'a> for &'b T { - type Bar = &'a T; - fn foo(&'a self) -> &'a T { - self - } -} - -pub fn uncallable<T, F>(x: T, f: F) -where - T: for<'a> Foo<'a>, - F: for<'a> Fn(<T as Foo<'a>>::Bar), -{ - f(x.foo()); -} - -pub fn catalyst(x: &i32) { - broken(x, |_| {}) -} - -pub fn broken<F: Fn(&i32)>(x: &i32, f: F) { - uncallable(x, |y| f(y)); -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-56556.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-56556.rs deleted file mode 100644 index 4d38cb19e..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-56556.rs +++ /dev/null @@ -1,30 +0,0 @@ -// check-pass - -fn foo<T>(t: T) -> usize -where - for<'a> &'a T: IntoIterator, - for<'a> <&'a T as IntoIterator>::IntoIter: ExactSizeIterator, -{ - t.into_iter().len() -} - -fn main() { - foo::<Vec<u32>>(vec![]); -} - -mod another { - use std::ops::Deref; - - fn test<T, TDeref>() - where - T: Deref<Target = TDeref>, - TDeref: ?Sized, - for<'a> &'a TDeref: IntoIterator, - for<'a> <&'a TDeref as IntoIterator>::IntoIter: Clone, - { - } - - fn main() { - test::<Vec<u8>, _>(); - } -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-1.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-1.rs deleted file mode 100644 index c6f29fa59..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-1.rs +++ /dev/null @@ -1,88 +0,0 @@ -// check-pass - -// FamilyType (GAT workaround) -pub trait FamilyLt<'a> { - type Out; -} - -struct RefMutFamily<T>(std::marker::PhantomData<T>, ()); -impl<'a, T: 'a> FamilyLt<'a> for RefMutFamily<T> { - type Out = &'a mut T; -} - -pub trait Execute { - type E: Inject; - fn execute(self, value: <<Self::E as Inject>::I as FamilyLt>::Out); -} - -pub trait Inject -where - Self: Sized, -{ - type I: for<'a> FamilyLt<'a>; - fn inject(_: &()) -> <Self::I as FamilyLt>::Out; -} - -impl<T: 'static> Inject for RefMutFamily<T> { - type I = Self; - fn inject(_: &()) -> <Self::I as FamilyLt>::Out { - unimplemented!() - } -} - -// This struct is only used to give a hint to the compiler about the type `Q` -struct Annotate<Q>(std::marker::PhantomData<Q>); -impl<Q> Annotate<Q> { - fn new() -> Self { - Self(std::marker::PhantomData) - } -} - -// This function annotate a closure so it can have Higher-Rank Lifetime Bounds -// -// See 'annotate' workaround: https://github.com/rust-lang/rust/issues/58052 -fn annotate<F, Q>(_q: Annotate<Q>, func: F) -> impl Execute + 'static -where - F: for<'r> FnOnce(<<Q as Inject>::I as FamilyLt<'r>>::Out) + 'static, - Q: Inject + 'static, -{ - let wrapper: Wrapper<Q, F> = Wrapper(std::marker::PhantomData, func); - wrapper -} - -struct Wrapper<Q, F>(std::marker::PhantomData<Q>, F); -impl<Q, F> Execute for Wrapper<Q, F> - where - Q: Inject, - F: for<'r> FnOnce(<<Q as Inject>::I as FamilyLt<'r>>::Out), -{ - type E = Q; - - fn execute(self, value: <<Self::E as Inject>::I as FamilyLt>::Out) { - (self.1)(value) - } -} - -struct Task { - _processor: Box<dyn FnOnce()>, -} - -// This function consume the closure -fn task<P>(processor: P) -> Task -where P: Execute + 'static { - Task { - _processor: Box::new(move || { - let q = P::E::inject(&()); - processor.execute(q); - }) - } -} - -fn main() { - task(annotate( - Annotate::<RefMutFamily<usize>>::new(), - |value: &mut usize| { - *value = 2; - } - )); -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-2.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-2.rs deleted file mode 100644 index 002054732..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-2.rs +++ /dev/null @@ -1,33 +0,0 @@ -// check-pass - -use std::marker::PhantomData; - -trait Lt<'a> { - type T; -} -struct Id<T>(PhantomData<T>); -impl<'a,T> Lt<'a> for Id<T> { - type T = T; -} - -struct Ref<T>(PhantomData<T>) where T: ?Sized; -impl<'a,T> Lt<'a> for Ref<T> -where T: 'a + Lt<'a> + ?Sized -{ - type T = &'a T; -} -struct Mut<T>(PhantomData<T>) where T: ?Sized; -impl<'a,T> Lt<'a> for Mut<T> -where T: 'a + Lt<'a> + ?Sized -{ - type T = &'a mut T; -} - -struct C<I,O>(for<'a> fn(<I as Lt<'a>>::T) -> O) where I: for<'a> Lt<'a>; - - -fn main() { - let c = C::<Id<_>,_>(|()| 3); - c.0(()); - -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-3.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-3.rs deleted file mode 100644 index d84e30f49..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-3.rs +++ /dev/null @@ -1,32 +0,0 @@ -trait ATC<'a> { - type Type: Sized; -} - -trait WithDefault: for<'a> ATC<'a> { - fn with_default<F: for<'a> Fn(<Self as ATC<'a>>::Type)>(f: F); -} - -fn call<'b, T: for<'a> ATC<'a>, F: for<'a> Fn(<T as ATC<'a>>::Type)>( - f: F, - x: <T as ATC<'b>>::Type, -) { - f(x); -} - -impl<'a> ATC<'a> for () { - type Type = Self; -} - -impl WithDefault for () { - fn with_default<F: for<'a> Fn(<Self as ATC<'a>>::Type)>(f: F) { - // Errors with a bogus type mismatch. - //f(()); - // Going through another generic function works fine. - call(f, ()); - //~^ expected a - } -} - -fn main() { - // <()>::with_default(|_| {}); -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-3.stderr b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-3.stderr deleted file mode 100644 index b30dd36d2..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-3.stderr +++ /dev/null @@ -1,19 +0,0 @@ -error[E0277]: expected a `Fn<(<_ as ATC<'a>>::Type,)>` closure, found `F` - --> $DIR/issue-62529-3.rs:25:14 - | -LL | call(f, ()); - | ---- ^ expected an `Fn<(<_ as ATC<'a>>::Type,)>` closure, found `F` - | | - | required by a bound introduced by this call - | - = note: expected a closure with arguments `((),)` - found a closure with arguments `(<_ as ATC<'a>>::Type,)` -note: required by a bound in `call` - --> $DIR/issue-62529-3.rs:9:36 - | -LL | fn call<'b, T: for<'a> ATC<'a>, F: for<'a> Fn(<T as ATC<'a>>::Type)>( - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `call` - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-4.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-4.rs deleted file mode 100644 index 8c2a59868..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-4.rs +++ /dev/null @@ -1,39 +0,0 @@ -// check-pass - -use std::marker::PhantomData; -use std::mem; - -trait Container<'a> { - type Root: 'a; -} - -type RootOf<'a, T> = <T as Container<'a>>::Root; - -struct Test<'a, T> where T: Container<'a> { - pub root: T::Root, - marker: PhantomData<&'a mut &'a mut ()>, -} - -impl<'a, 'b> Container<'b> for &'a str { - type Root = &'b str; -} - -impl<'a, T> Test<'a, T> where T: for<'b> Container<'b> { - fn new(root: RootOf<'a, T>) -> Test<'a, T> { - Test { - root: root, - marker: PhantomData - } - } - - fn with_mut<F, R>(&mut self, f: F) -> R where - F: for<'b> FnOnce(&'b mut RootOf<'b, T>) -> R { - f(unsafe { mem::transmute(&mut self.root) }) - } -} - -fn main() { - let val = "root"; - let mut test: Test<&str> = Test::new(val); - test.with_mut(|_| { }); -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-5.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-5.rs deleted file mode 100644 index 03f257a02..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-5.rs +++ /dev/null @@ -1,27 +0,0 @@ -// check-pass - -pub struct Struct {} - -pub trait Trait<'a> { - type Assoc; - - fn method() -> Self::Assoc; -} - -impl<'a> Trait<'a> for Struct { - type Assoc = (); - - fn method() -> Self::Assoc {} -} - -pub fn function<F, T>(f: F) -where - F: for<'a> FnOnce(<T as Trait<'a>>::Assoc), - T: for<'b> Trait<'b>, -{ - f(T::method()); -} - -fn main() { - function::<_, Struct>(|_| {}); -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-6.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-6.rs deleted file mode 100644 index 74a4785e4..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-62529-6.rs +++ /dev/null @@ -1,77 +0,0 @@ -// check-pass - -use std::cell::RefMut; - -fn main() { - StateMachine2::Init.resume(); -} - -enum StateMachine2<'a> { - Init, - #[allow(dead_code)] // match required for ICE - AfterTwoYields { - p: Backed<'a, *mut String>, - }, -} - -impl<'a> StateMachine2<'a> { - fn take(&self) -> Self { - StateMachine2::Init - } -} - -impl<'a> StateMachine2<'a> { - fn resume(&mut self) -> () { - use StateMachine2::*; - match self.take() { - AfterTwoYields { p } => { - p.with(|_| {}); - } - _ => panic!("Resume after completed."), - } - } -} - -unsafe trait Unpack<'a> { - type Unpacked: 'a; - - fn unpack(&self) -> Self::Unpacked { - unsafe { std::mem::transmute_copy(&self) } - } -} - -unsafe trait Pack { - type Packed; - - fn pack(&self) -> Self::Packed { - unsafe { std::mem::transmute_copy(&self) } - } -} - -unsafe impl<'a> Unpack<'a> for String { - type Unpacked = String; -} - -unsafe impl Pack for String { - type Packed = String; -} - -unsafe impl<'a> Unpack<'a> for *mut String { - type Unpacked = &'a mut String; -} - -unsafe impl<'a> Pack for &'a mut String { - type Packed = *mut String; -} - -struct Backed<'a, U>(RefMut<'a, Option<String>>, U); - -impl<'a, 'b, U: Unpack<'b>> Backed<'a, U> { - fn with<F>(self, f: F) -> Backed<'a, ()> - where - F: for<'f> FnOnce(<U as Unpack<'f>>::Unpacked) -> (), - { - let result = f(self.1.unpack()); - Backed(self.0, result) - } -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-70120.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-70120.rs deleted file mode 100644 index 3ced40230..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-70120.rs +++ /dev/null @@ -1,31 +0,0 @@ -// check-pass - -pub trait MyTrait<'a> { - type Output: 'a; - fn gimme_value(&self) -> Self::Output; -} - -pub struct MyStruct; - -impl<'a> MyTrait<'a> for MyStruct { - type Output = &'a usize; - fn gimme_value(&self) -> Self::Output { - unimplemented!() - } -} - -fn meow<T, F>(t: T, f: F) -where - T: for<'any> MyTrait<'any>, - F: for<'any2> Fn(<T as MyTrait<'any2>>::Output), -{ - let v = t.gimme_value(); - f(v); -} - -fn main() { - let struc = MyStruct; - meow(struc, |foo| { - println!("{:?}", foo); - }) -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.migrate.stderr b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.migrate.stderr deleted file mode 100644 index 0f38f8e32..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.migrate.stderr +++ /dev/null @@ -1,79 +0,0 @@ -error[E0308]: mismatched types - --> $DIR/issue-71955.rs:54:5 - | -LL | foo(bar, "string", |s| s.len() == 5); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other - | - = note: expected type `for<'r, 's> FnOnce<(&'r &'s str,)>` - found type `for<'r> FnOnce<(&'r &str,)>` -note: this closure does not fulfill the lifetime requirements - --> $DIR/issue-71955.rs:54:24 - | -LL | foo(bar, "string", |s| s.len() == 5); - | ^^^^^^^^^^^^^^^^ -note: the lifetime requirement is introduced here - --> $DIR/issue-71955.rs:34:9 - | -LL | F2: FnOnce(&<F1 as Parser>::Output) -> bool - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error[E0308]: mismatched types - --> $DIR/issue-71955.rs:54:5 - | -LL | foo(bar, "string", |s| s.len() == 5); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other - | - = note: expected type `FnOnce<(&&str,)>` - found type `for<'r> FnOnce<(&'r &str,)>` -note: this closure does not fulfill the lifetime requirements - --> $DIR/issue-71955.rs:54:24 - | -LL | foo(bar, "string", |s| s.len() == 5); - | ^^^^^^^^^^^^^^^^ -note: the lifetime requirement is introduced here - --> $DIR/issue-71955.rs:34:44 - | -LL | F2: FnOnce(&<F1 as Parser>::Output) -> bool - | ^^^^ - -error[E0308]: mismatched types - --> $DIR/issue-71955.rs:58:5 - | -LL | foo(baz, "string", |s| s.0.len() == 5); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other - | - = note: expected type `for<'r, 's> FnOnce<(&'r Wrapper<'s>,)>` - found type `for<'r> FnOnce<(&'r Wrapper<'_>,)>` -note: this closure does not fulfill the lifetime requirements - --> $DIR/issue-71955.rs:58:24 - | -LL | foo(baz, "string", |s| s.0.len() == 5); - | ^^^^^^^^^^^^^^^^^^ -note: the lifetime requirement is introduced here - --> $DIR/issue-71955.rs:34:9 - | -LL | F2: FnOnce(&<F1 as Parser>::Output) -> bool - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error[E0308]: mismatched types - --> $DIR/issue-71955.rs:58:5 - | -LL | foo(baz, "string", |s| s.0.len() == 5); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other - | - = note: expected type `FnOnce<(&Wrapper<'_>,)>` - found type `for<'r> FnOnce<(&'r Wrapper<'_>,)>` -note: this closure does not fulfill the lifetime requirements - --> $DIR/issue-71955.rs:58:24 - | -LL | foo(baz, "string", |s| s.0.len() == 5); - | ^^^^^^^^^^^^^^^^^^ -note: the lifetime requirement is introduced here - --> $DIR/issue-71955.rs:34:44 - | -LL | F2: FnOnce(&<F1 as Parser>::Output) -> bool - | ^^^^ - -error: aborting due to 4 previous errors - -For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.rs deleted file mode 100644 index 1d90226a3..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.rs +++ /dev/null @@ -1,51 +0,0 @@ -// check-fail -#![feature(rustc_attrs)] - -trait Parser<'s> { - type Output; - - fn call(&self, input: &'s str) -> (&'s str, Self::Output); -} - -impl<'s, F, T> Parser<'s> for F -where F: Fn(&'s str) -> (&'s str, T) { - type Output = T; - fn call(&self, input: &'s str) -> (&'s str, T) { - self(input) - } -} - -fn foo<F1, F2>( - f1: F1, - base: &'static str, - f2: F2 -) -where - F1: for<'a> Parser<'a>, - F2: FnOnce(&<F1 as Parser>::Output) -> bool -{ - let s: String = base.to_owned(); - let str_ref = s.as_ref(); - let (remaining, produced) = f1.call(str_ref); - assert!(f2(&produced)); - assert_eq!(remaining.len(), 0); -} - -struct Wrapper<'a>(&'a str); - -fn main() { - fn bar<'a>(s: &'a str) -> (&'a str, &'a str) { - (&s[..1], &s[..]) - } - - fn baz<'a>(s: &'a str) -> (&'a str, Wrapper<'a>) { - (&s[..1], Wrapper(&s[..])) - } - - foo(bar, "string", |s| s.len() == 5); - //~^ ERROR mismatched types - //~| ERROR mismatched types - foo(baz, "string", |s| s.0.len() == 5); - //~^ ERROR mismatched types - //~| ERROR mismatched types -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.stderr b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.stderr deleted file mode 100644 index 4ef96cd95..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-71955.stderr +++ /dev/null @@ -1,79 +0,0 @@ -error[E0308]: mismatched types - --> $DIR/issue-71955.rs:45:5 - | -LL | foo(bar, "string", |s| s.len() == 5); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other - | - = note: expected trait `for<'a, 'b> FnOnce<(&'a &'b str,)>` - found trait `for<'a> FnOnce<(&'a &str,)>` -note: this closure does not fulfill the lifetime requirements - --> $DIR/issue-71955.rs:45:24 - | -LL | foo(bar, "string", |s| s.len() == 5); - | ^^^ -note: the lifetime requirement is introduced here - --> $DIR/issue-71955.rs:25:9 - | -LL | F2: FnOnce(&<F1 as Parser>::Output) -> bool - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error[E0308]: mismatched types - --> $DIR/issue-71955.rs:45:5 - | -LL | foo(bar, "string", |s| s.len() == 5); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other - | - = note: expected trait `for<'a, 'b> FnOnce<(&'a &'b str,)>` - found trait `for<'a> FnOnce<(&'a &str,)>` -note: this closure does not fulfill the lifetime requirements - --> $DIR/issue-71955.rs:45:24 - | -LL | foo(bar, "string", |s| s.len() == 5); - | ^^^ -note: the lifetime requirement is introduced here - --> $DIR/issue-71955.rs:25:44 - | -LL | F2: FnOnce(&<F1 as Parser>::Output) -> bool - | ^^^^ - -error[E0308]: mismatched types - --> $DIR/issue-71955.rs:48:5 - | -LL | foo(baz, "string", |s| s.0.len() == 5); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other - | - = note: expected trait `for<'a, 'b> FnOnce<(&'a Wrapper<'b>,)>` - found trait `for<'a> FnOnce<(&'a Wrapper<'_>,)>` -note: this closure does not fulfill the lifetime requirements - --> $DIR/issue-71955.rs:48:24 - | -LL | foo(baz, "string", |s| s.0.len() == 5); - | ^^^ -note: the lifetime requirement is introduced here - --> $DIR/issue-71955.rs:25:9 - | -LL | F2: FnOnce(&<F1 as Parser>::Output) -> bool - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -error[E0308]: mismatched types - --> $DIR/issue-71955.rs:48:5 - | -LL | foo(baz, "string", |s| s.0.len() == 5); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other - | - = note: expected trait `for<'a, 'b> FnOnce<(&'a Wrapper<'b>,)>` - found trait `for<'a> FnOnce<(&'a Wrapper<'_>,)>` -note: this closure does not fulfill the lifetime requirements - --> $DIR/issue-71955.rs:48:24 - | -LL | foo(baz, "string", |s| s.0.len() == 5); - | ^^^ -note: the lifetime requirement is introduced here - --> $DIR/issue-71955.rs:25:44 - | -LL | F2: FnOnce(&<F1 as Parser>::Output) -> bool - | ^^^^ - -error: aborting due to 4 previous errors - -For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-74261.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-74261.rs deleted file mode 100644 index 93ccb4268..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-74261.rs +++ /dev/null @@ -1,30 +0,0 @@ -// check-pass - -use std::marker::PhantomData; - -trait A<'a> { - type B; - fn b(self) -> Self::B; -} - -struct T; -struct S<'a>(PhantomData<&'a ()>); - -impl<'a> A<'a> for T { - type B = S<'a>; - fn b(self) -> Self::B { - S(PhantomData) - } -} - -fn s<TT, F>(t: TT, f: F) -where - TT: for<'a> A<'a>, - F: for<'a> FnOnce(<TT as A<'a>>::B) -{ - f(t.b()); -} - -fn main() { - s(T, |_| {}); -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-76956.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-76956.rs deleted file mode 100644 index 583470080..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-76956.rs +++ /dev/null @@ -1,15 +0,0 @@ -// check-pass - -use std::ops::Deref; - -struct Data { - boxed: Box<&'static i32> -} - -impl Data { - fn use_data(&self, user: impl for <'a> FnOnce(<Box<&'a i32> as Deref>::Target)) { - user(*self.boxed) - } -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-80706.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-80706.rs deleted file mode 100644 index 00a866f22..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-80706.rs +++ /dev/null @@ -1,71 +0,0 @@ -// build-pass -// edition:2018 - -type BoxFuture<T> = std::pin::Pin<Box<dyn std::future::Future<Output=T>>>; - -fn main() { - f(); -} - -async fn f() { - run("dependency").await; -} - -struct InMemoryStorage; - -struct User<'dep> { - dep: &'dep str, -} - -impl<'a> StorageRequest<InMemoryStorage> for SaveUser<'a> { - fn execute(&self) -> BoxFuture<Result<(), String>> { - todo!() - } -} - -trait Storage { - type Error; -} - -impl Storage for InMemoryStorage { - type Error = String; -} - -trait StorageRequestReturnType { - type Output; -} - -trait StorageRequest<S: Storage>: StorageRequestReturnType { - fn execute( - &self, - ) -> BoxFuture<Result<<Self as StorageRequestReturnType>::Output, <S as Storage>::Error>>; -} - -struct SaveUser<'a> { - name: &'a str, -} - -impl<'a> StorageRequestReturnType for SaveUser<'a> { - type Output = (); -} - -impl<'dep> User<'dep> { - async fn save<S>(self) - where - S: Storage, - for<'a> SaveUser<'a>: StorageRequest<S>, - { - SaveUser { name: "Joe" } - .execute() - .await; - } -} - -async fn run<S>(dep: &str) -where - S: Storage, - for<'a> SaveUser<'a>: StorageRequest<S>, - for<'a> SaveUser<'a>: StorageRequestReturnType, -{ - User { dep }.save().await; -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-80956.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-80956.rs deleted file mode 100644 index 6316ceea1..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-80956.rs +++ /dev/null @@ -1,21 +0,0 @@ -// check-pass - -trait Bar { - type Type; -} -struct Foo<'a>(&'a ()); -impl<'a> Bar for Foo<'a> { - type Type = (); -} - -fn func<'a>(_: <Foo<'a> as Bar>::Type) {} -fn assert_is_func<A>(_: fn(A)) {} - -fn test() -where - for<'a> <Foo<'a> as Bar>::Type: Sized, -{ - assert_is_func(func); -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-81809.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-81809.rs deleted file mode 100644 index f6ab9c203..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-81809.rs +++ /dev/null @@ -1,21 +0,0 @@ -// check-pass - -pub trait Indexable { - type Idx; -} -impl Indexable for u8 { - type Idx = u8; -} -impl Indexable for u16 { - type Idx = u16; -} - -pub trait Indexer<T: Indexable>: std::ops::Index<T::Idx, Output = T> {} - -trait StoreIndex: Indexer<u8> + Indexer<u16> {} - -fn foo(st: &impl StoreIndex) -> &dyn StoreIndex { - st as &dyn StoreIndex -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-85455.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-85455.rs deleted file mode 100644 index 8aa29926d..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-85455.rs +++ /dev/null @@ -1,19 +0,0 @@ -#![feature(unboxed_closures)] - -trait SomeTrait<'a> { - type Associated; -} - -fn give_me_ice<T>() { - callee::<fn(&()) -> <T as SomeTrait<'_>>::Associated>(); - //~^ ERROR the trait bound `for<'a> T: SomeTrait<'a>` is not satisfied [E0277] - //~| ERROR the trait bound `for<'a> T: SomeTrait<'a>` is not satisfied [E0277] -} - -fn callee<T: Fn<(&'static (),)>>() { - println!("{}", std::any::type_name::<<T as FnOnce<(&'static (),)>>::Output>()); -} - -fn main() { - give_me_ice::<()>(); -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-85455.stderr b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-85455.stderr deleted file mode 100644 index 3240518fb..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-85455.stderr +++ /dev/null @@ -1,25 +0,0 @@ -error[E0277]: the trait bound `for<'a> T: SomeTrait<'a>` is not satisfied - --> $DIR/issue-85455.rs:8:14 - | -LL | callee::<fn(&()) -> <T as SomeTrait<'_>>::Associated>(); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> SomeTrait<'a>` is not implemented for `T` - | -help: consider restricting type parameter `T` - | -LL | fn give_me_ice<T: for<'a> SomeTrait<'a>>() { - | +++++++++++++++++++++++ - -error[E0277]: the trait bound `for<'a> T: SomeTrait<'a>` is not satisfied - --> $DIR/issue-85455.rs:8:5 - | -LL | callee::<fn(&()) -> <T as SomeTrait<'_>>::Associated>(); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `for<'a> SomeTrait<'a>` is not implemented for `T` - | -help: consider restricting type parameter `T` - | -LL | fn give_me_ice<T: for<'a> SomeTrait<'a>>() { - | +++++++++++++++++++++++ - -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89118.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89118.rs deleted file mode 100644 index fffb54f86..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89118.rs +++ /dev/null @@ -1,32 +0,0 @@ -trait BufferMut {} -struct Ctx<D>(D); - -trait BufferUdpStateContext<B> {} -impl<B: BufferMut, C> BufferUdpStateContext<B> for C {} - -trait StackContext -where - Ctx<()>: for<'a> BufferUdpStateContext<&'a ()>, -{ - type Dispatcher; -} - -trait TimerContext { - type Handler; -} -impl<C> TimerContext for C -where - C: StackContext, - //~^ ERROR: is not satisfied [E0277] -{ - type Handler = Ctx<C::Dispatcher>; - //~^ ERROR: is not satisfied [E0277] -} - -struct EthernetWorker<C>(C) -where - Ctx<()>: for<'a> BufferUdpStateContext<&'a ()>; -impl<C> EthernetWorker<C> {} -//~^ ERROR: is not satisfied [E0277] - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89118.stderr b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89118.stderr deleted file mode 100644 index edef6ccd3..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89118.stderr +++ /dev/null @@ -1,69 +0,0 @@ -error[E0277]: the trait bound `for<'a> &'a (): BufferMut` is not satisfied - --> $DIR/issue-89118.rs:19:8 - | -LL | C: StackContext, - | ^^^^^^^^^^^^ the trait `for<'a> BufferMut` is not implemented for `&'a ()` - | -note: required for `Ctx<()>` to implement `for<'a> BufferUdpStateContext<&'a ()>` - --> $DIR/issue-89118.rs:5:23 - | -LL | impl<B: BufferMut, C> BufferUdpStateContext<B> for C {} - | --------- ^^^^^^^^^^^^^^^^^^^^^^^^ ^ - | | - | unsatisfied trait bound introduced here -note: required by a bound in `StackContext` - --> $DIR/issue-89118.rs:9:14 - | -LL | trait StackContext - | ------------ required by a bound in this trait -LL | where -LL | Ctx<()>: for<'a> BufferUdpStateContext<&'a ()>, - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `StackContext` - -error[E0277]: the trait bound `for<'a> &'a (): BufferMut` is not satisfied - --> $DIR/issue-89118.rs:29:9 - | -LL | impl<C> EthernetWorker<C> {} - | ^^^^^^^^^^^^^^^^^ the trait `for<'a> BufferMut` is not implemented for `&'a ()` - | -note: required for `Ctx<()>` to implement `for<'a> BufferUdpStateContext<&'a ()>` - --> $DIR/issue-89118.rs:5:23 - | -LL | impl<B: BufferMut, C> BufferUdpStateContext<B> for C {} - | --------- ^^^^^^^^^^^^^^^^^^^^^^^^ ^ - | | - | unsatisfied trait bound introduced here -note: required by a bound in `EthernetWorker` - --> $DIR/issue-89118.rs:28:14 - | -LL | struct EthernetWorker<C>(C) - | -------------- required by a bound in this struct -LL | where -LL | Ctx<()>: for<'a> BufferUdpStateContext<&'a ()>; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `EthernetWorker` - -error[E0277]: the trait bound `for<'a> &'a (): BufferMut` is not satisfied - --> $DIR/issue-89118.rs:22:20 - | -LL | type Handler = Ctx<C::Dispatcher>; - | ^^^^^^^^^^^^^^^^^^ the trait `for<'a> BufferMut` is not implemented for `&'a ()` - | -note: required for `Ctx<()>` to implement `for<'a> BufferUdpStateContext<&'a ()>` - --> $DIR/issue-89118.rs:5:23 - | -LL | impl<B: BufferMut, C> BufferUdpStateContext<B> for C {} - | --------- ^^^^^^^^^^^^^^^^^^^^^^^^ ^ - | | - | unsatisfied trait bound introduced here -note: required by a bound in `StackContext` - --> $DIR/issue-89118.rs:9:14 - | -LL | trait StackContext - | ------------ required by a bound in this trait -LL | where -LL | Ctx<()>: for<'a> BufferUdpStateContext<&'a ()>, - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `StackContext` - -error: aborting due to 3 previous errors - -For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89436.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89436.rs deleted file mode 100644 index f7e467b37..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-89436.rs +++ /dev/null @@ -1,44 +0,0 @@ -// check-pass - -#![allow(unused)] - -trait MiniYokeable<'a> { - type Output; -} - -struct MiniYoke<Y: for<'a> MiniYokeable<'a>> { - pub yokeable: Y, -} - -fn map_project_broken<Y, P>( - source: MiniYoke<Y>, - f: impl for<'a> FnOnce( - <Y as MiniYokeable<'a>>::Output, - core::marker::PhantomData<&'a ()>, - ) -> <P as MiniYokeable<'a>>::Output, -) -> MiniYoke<P> -where - Y: for<'a> MiniYokeable<'a>, - P: for<'a> MiniYokeable<'a> -{ - unimplemented!() -} - -struct Bar<'a> { - string_1: &'a str, - string_2: &'a str, -} - -impl<'a> MiniYokeable<'a> for Bar<'static> { - type Output = Bar<'a>; -} - -impl<'a> MiniYokeable<'a> for &'static str { - type Output = &'a str; -} - -fn demo_broken(bar: MiniYoke<Bar<'static>>) -> MiniYoke<&'static str> { - map_project_broken(bar, |bar, _| bar.string_1) -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90612.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90612.rs deleted file mode 100644 index effc32945..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90612.rs +++ /dev/null @@ -1,41 +0,0 @@ -// check-pass - -use std::marker::PhantomData; - -trait Family: Sized { - type Item<'a>; - - fn apply_all<F>(&self, f: F) - where - F: FamilyItemFn<Self> { } -} - -struct Array<T>(PhantomData<T>); - -impl<T: 'static> Family for Array<T> { - type Item<'a> = &'a T; -} - -trait FamilyItemFn<T: Family> { - fn apply(&self, item: T::Item<'_>); -} - -impl<T, F> FamilyItemFn<T> for F -where - T: Family, - for<'a> F: Fn(T::Item<'a>) -{ - fn apply(&self, item: T::Item<'_>) { - (*self)(item); - } -} - -fn process<T: 'static>(array: Array<T>) { - // Works - array.apply_all(|x: &T| { }); - - // ICE: NoSolution - array.apply_all(|x: <Array<T> as Family>::Item<'_>| { }); -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90638.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90638.rs deleted file mode 100644 index 628b5cba1..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90638.rs +++ /dev/null @@ -1,35 +0,0 @@ -//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, _f: for<'a> fn(<Y as Yokeable<'a>>::Output, &'a ()) - -> <Y2 as Yokeable<'a>>::Output) -> Yoke<Y2> { - - unimplemented!() - } -} - -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> - { - x.project(|data, _| { - Box::new(data) - }) -} - - -impl<'a> Yokeable<'a> for Box<dyn IsCovariant<'static> + 'static> { - type Output = Box<dyn IsCovariant<'a> + 'a>; -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90875.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90875.rs deleted file mode 100644 index ffd6857d8..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90875.rs +++ /dev/null @@ -1,31 +0,0 @@ -// check-pass - -trait Variable<'a> { - type Type; -} - -impl Variable<'_> for () { - type Type = (); -} - -fn check<F, T>(_: F) -where - F: Fn(T), // <- if removed, all fn_* then require type annotations - F: for<'a> Fn(<T as Variable<'a>>::Type), - T: for<'a> Variable<'a>, -{ -} - -fn test(arg: impl Fn(())) { - fn fn_1(_: ()) {} - let fn_2 = |_: ()| (); - let fn_3 = |a| fn_1(a); - let fn_4 = arg; - - check(fn_1); // Error - check(fn_2); // Ok - check(fn_3); // Ok - check(fn_4); // Error -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90950.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90950.rs deleted file mode 100644 index ab9d9a7ce..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90950.rs +++ /dev/null @@ -1,53 +0,0 @@ -// check-fail -// known-bug: #90950 - -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, -// f: for<'a> fn(<Y as Yokeable<'a>>::Output, &'a (), -// ) -> <Y2 as Yokeable<'a>>::Output) -> Yoke<Y2> { -// unimplemented!() -// } -// } - -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> - { - // x.project(|data, _| { - // Box::new(data) - // }) - unimplemented!() -} - - -impl<'a> Yokeable<'a> for Box<dyn IsCovariant<'static> + 'static> { - type Output = Box<dyn IsCovariant<'a> + 'a>; -} - -// this impl is mostly an example and unnecessary for the pure repro -use std::borrow::*; -impl<'a, T: ToOwned + ?Sized> Yokeable<'a> for Cow<'static, T> { - type Output = Cow<'a, 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) -} - -fn main() {} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90950.stderr b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90950.stderr deleted file mode 100644 index 5be33bccd..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/issue-90950.stderr +++ /dev/null @@ -1,21 +0,0 @@ -error[E0277]: the trait bound `for<'a> <_ as Yokeable<'a>>::Output: IsCovariant<'a>` is not satisfied - --> $DIR/issue-90950.rs:50:12 - | -LL | upcast(y) - | ------ ^ the trait `for<'a> IsCovariant<'a>` is not implemented for `<_ as Yokeable<'a>>::Output` - | | - | required by a bound introduced by this call - | - = help: the trait `IsCovariant<'a>` is implemented for `std::borrow::Cow<'a, T>` -note: required by a bound in `upcast` - --> $DIR/issue-90950.rs:27:42 - | -LL | fn upcast<Y>(x: Yoke<Y>) -> Yoke<Box<dyn IsCovariant<'static> + 'static>> where - | ------ required by a bound in this function -LL | Y: for<'a> Yokeable<'a>, -LL | for<'a> <Y as Yokeable<'a>>::Output: IsCovariant<'a> - | ^^^^^^^^^^^^^^^ required by this bound in `upcast` - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/norm-before-method-resolution.rs b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/norm-before-method-resolution.rs deleted file mode 100644 index 7693b1182..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/norm-before-method-resolution.rs +++ /dev/null @@ -1,23 +0,0 @@ -// check-fail -// known-bug: #89196 - -// Should pass, but we normalize and check bounds before we resolve the generics -// of the function (which we know because of the return type). - -trait Trait<'a> { - type Out; -} - -impl<'a, T> Trait<'a> for T { - type Out = T; -} - -fn weird_bound<X>() -> X - where - for<'a> X: Trait<'a>, - for<'a> <X as Trait<'a>>::Out: Copy -{ todo!() } - -fn main() { - let _: () = weird_bound(); -} diff --git a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/norm-before-method-resolution.stderr b/tests/ui/higher-rank-trait-bounds/normalize-under-binder/norm-before-method-resolution.stderr deleted file mode 100644 index 73388a725..000000000 --- a/tests/ui/higher-rank-trait-bounds/normalize-under-binder/norm-before-method-resolution.stderr +++ /dev/null @@ -1,18 +0,0 @@ -error[E0277]: the trait bound `for<'a> <_ as Trait<'a>>::Out: Copy` is not satisfied - --> $DIR/norm-before-method-resolution.rs:22:17 - | -LL | let _: () = weird_bound(); - | ^^^^^^^^^^^ the trait `for<'a> Copy` is not implemented for `<_ as Trait<'a>>::Out` - | -note: required by a bound in `weird_bound` - --> $DIR/norm-before-method-resolution.rs:18:40 - | -LL | fn weird_bound<X>() -> X - | ----------- required by a bound in this function -... -LL | for<'a> <X as Trait<'a>>::Out: Copy - | ^^^^ required by this bound in `weird_bound` - -error: aborting due to previous error - -For more information about this error, try `rustc --explain E0277`. |