user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #113303 - compiler-errors:yeet-chalk, r=lcnr

Browse source 
Remove chalk support from the compiler

Removes chalk (`-Ztrait-solver=chalk`) from the compiler and prunes any dead code resulting from this, mainly:
* Remove the chalk compatibility layer in `compiler/rustc_traits/src/chalk`
* Remove the chalk flag `-Ztrait-solver=chalk` and its `TraitEngine` implementation
* Remove `TypeWellFormedFromEnv` (and its many `bug!()` match arms)
* Remove the chalk migration mode from compiletest
* Remove the `chalkify` UI tests (do we want to keep any of these, but migrate them to `-Ztrait-solver=next`??)

Fulfills rust-lang/types-team#93.

r? `@jackh726`
This commit is contained in:
bors 2023-07-04 09:09:09 +00:00
commit cd68ead9ec
89 changed files with 35 additions and 3864 deletions
Download patch file Download diff file Expand all files Collapse all files

20
tests/ui/chalkify/arithmetic.rs
View file

@ -1,20 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
fn main() {
1 + 2;
3 * 6;
2 - 5;
17 / 6;
23 % 11;
4 & 6;
7 | 15;
4 << 7;
123 >> 3;
1 == 2;
5 != 5;
6 < 2;
7 > 11;
3 <= 1;
9 >= 14;
}

6
tests/ui/chalkify/assert.rs
View file

@ -1,6 +0,0 @@
// run-pass
// compile-flags: -Z trait-solver=chalk
fn main() {
assert_eq!(1, 1);
}

12
tests/ui/chalkify/basic.rs
View file

@ -1,12 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
trait Foo {}
struct Bar {}
impl Foo for Bar {}
fn main() -> () {
let _ = Bar {};
}

25
tests/ui/chalkify/bugs/async.rs
View file

@ -1,25 +0,0 @@
// edition:2021
// known-bug: unknown
// unset-rustc-env:RUST_BACKTRACE
// compile-flags:-Z trait-solver=chalk
// error-pattern:internal compiler error
// failure-status:101
// normalize-stderr-test "DefId\([^)]*\)" -> "..."
// normalize-stderr-test "\nerror: internal compiler error.*\n\n" -> ""
// normalize-stderr-test "note:.*unexpectedly panicked.*\n\n" -> ""
// normalize-stderr-test "note: we would appreciate a bug report.*\n\n" -> ""
// normalize-stderr-test "note: compiler flags.*\n\n" -> ""
// normalize-stderr-test "note: rustc.*running on.*\n\n" -> ""
// normalize-stderr-test "thread.*panicked.*\n" -> ""
// normalize-stderr-test "stack backtrace:\n" -> ""
// normalize-stderr-test "\s\d{1,}: .*\n" -> ""
// normalize-stderr-test "\s at .*\n" -> ""
// normalize-stderr-test ".*note: Some details.*\n" -> ""
// normalize-stderr-test "\n\n[ ]*\n" -> ""
// normalize-stderr-test "compiler/.*: projection" -> "projection"
fn main() -> () {}
async fn foo(x: u32) -> u32 {
x
}

22
tests/ui/chalkify/bugs/async.stderr
View file

@ -1,22 +0,0 @@
error[E0277]: `[async fn body@$DIR/async.rs:23:29: 25:2]` is not a future
--> $DIR/async.rs:23:25
|
LL | async fn foo(x: u32) -> u32 {
| ^^^ `[async fn body@$DIR/async.rs:23:29: 25:2]` is not a future
|
= help: the trait `Future` is not implemented for `[async fn body@$DIR/async.rs:23:29: 25:2]`
= note: [async fn body@$DIR/async.rs:23:29: 25:2] must be a future or must implement `IntoFuture` to be awaited
error: internal compiler error: projection clauses should be implied from elsewhere. obligation: `Obligation(predicate=Binder { value: ProjectionPredicate(AliasTy { substs: [[async fn body@$DIR/async.rs:23:29: 25:2]], def_id: ... }, Term::Ty(u32)), bound_vars: [] }, depth=0)`
--> $DIR/async.rs:23:25
|
LL | async fn foo(x: u32) -> u32 {
| ^^^query stack during panic:
#0 [typeck] type-checking `foo`
#1 [type_of] computing type of `foo::{opaque#0}`
#2 [check_mod_item_types] checking item types in top-level module
#3 [analysis] running analysis passes on this crate
end of query stack
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.

45
tests/ui/chalkify/builtin-copy-clone.rs
View file

@ -1,45 +0,0 @@
// run-pass
// compile-flags: -Z trait-solver=chalk
// Test that `Clone` is correctly implemented for builtin types.
#[derive(Copy, Clone)]
struct S(#[allow(unused_tuple_struct_fields)] i32);
fn test_clone<T: Clone>(arg: T) {
let _ = arg.clone();
}
fn test_copy<T: Copy>(arg: T) {
let _ = arg;
let _ = arg;
}
fn test_copy_clone<T: Copy + Clone>(arg: T) {
test_copy(arg);
test_clone(arg);
}
fn foo() { }
fn main() {
// FIXME: add closures when they're considered WF
test_copy_clone(foo);
let f: fn() = foo;
test_copy_clone(f);
// FIXME(#86252): reinstate array test after chalk upgrade
//test_copy_clone([1; 56]);
test_copy_clone((1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1));
test_copy_clone((1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, true, 'a', 1.1));
test_copy_clone(());
test_copy_clone(((1, 1), (1, 1, 1), (1.1, 1, 1, 'a'), ()));
let a = (
(S(1), S(0)),
(
(S(0), S(0), S(1)),
S(0)
)
);
test_copy_clone(a);
}

16
tests/ui/chalkify/chalk_initial_program.rs
View file

@ -1,16 +0,0 @@
// compile-flags: -Z trait-solver=chalk
trait Foo { }
impl Foo for i32 { }
impl Foo for u32 { }
fn gimme<F: Foo>() { }
// Note: this also tests that `std::process::Termination` is implemented for `()`.
fn main() {
gimme::<i32>();
gimme::<u32>();
gimme::<f32>(); //~ERROR the trait bound `f32: Foo` is not satisfied
}

18
tests/ui/chalkify/chalk_initial_program.stderr
View file

@ -1,18 +0,0 @@
error[E0277]: the trait bound `f32: Foo` is not satisfied
--> $DIR/chalk_initial_program.rs:15:13
|
LL | gimme::<f32>();
| ^^^ the trait `Foo` is not implemented for `f32`
|
= help: the following other types implement trait `Foo`:
i32
u32
note: required by a bound in `gimme`
--> $DIR/chalk_initial_program.rs:9:13
|
LL | fn gimme<F: Foo>() { }
| ^^^ required by this bound in `gimme`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

38
tests/ui/chalkify/closure.rs
View file

@ -1,38 +0,0 @@
// compile-flags: -Z trait-solver=chalk
fn main() -> () {
let t = || {};
t();
let mut a = 0;
let mut b = move || {
a = 1;
};
b();
let mut c = b;
c();
b();
let mut a = 0;
let mut b = || {
a = 1;
};
b();
let mut c = b;
c();
b(); //~ ERROR
// FIXME(chalk): this doesn't quite work
/*
let b = |c| {
c
};
let a = &32;
b(a);
*/
}

22
tests/ui/chalkify/closure.stderr
View file

@ -1,22 +0,0 @@
error[E0382]: borrow of moved value: `b`
--> $DIR/closure.rs:27:5
|
LL | let mut c = b;
| - value moved here
...
LL | b();
| ^ value borrowed here after move
|
note: closure cannot be moved more than once as it is not `Copy` due to moving the variable `a` out of its environment
--> $DIR/closure.rs:20:9
|
LL | a = 1;
| ^
help: consider mutably borrowing `b`
|
LL | let mut c = &mut b;
| ++++
error: aborting due to previous error
For more information about this error, try `rustc --explain E0382`.

18
tests/ui/chalkify/generic_impls.rs
View file

@ -1,18 +0,0 @@
// compile-flags: -Z trait-solver=chalk
trait Foo { }
impl<T> Foo for (T, u32) { }
fn gimme<F: Foo>() { }
fn foo<T>() {
gimme::<(T, u32)>();
gimme::<(Option<T>, u32)>();
gimme::<(Option<T>, f32)>(); //~ ERROR
}
fn main() {
gimme::<(i32, u32)>();
gimme::<(i32, f32)>(); //~ ERROR
}

29
tests/ui/chalkify/generic_impls.stderr
View file

@ -1,29 +0,0 @@
error[E0277]: the trait bound `(Option<T>, f32): Foo` is not satisfied
--> $DIR/generic_impls.rs:12:13
|
LL | gimme::<(Option<T>, f32)>();
| ^^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `(Option<T>, f32)`
|
= help: the trait `Foo` is implemented for `(T, u32)`
note: required by a bound in `gimme`
--> $DIR/generic_impls.rs:7:13
|
LL | fn gimme<F: Foo>() { }
| ^^^ required by this bound in `gimme`
error[E0277]: the trait bound `(i32, f32): Foo` is not satisfied
--> $DIR/generic_impls.rs:17:13
|
LL | gimme::<(i32, f32)>();
| ^^^^^^^^^^ the trait `Foo` is not implemented for `(i32, f32)`
|
= help: the trait `Foo` is implemented for `(T, u32)`
note: required by a bound in `gimme`
--> $DIR/generic_impls.rs:7:13
|
LL | fn gimme<F: Foo>() { }
| ^^^ required by this bound in `gimme`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.

26
tests/ui/chalkify/impl_wf.rs
View file

@ -1,26 +0,0 @@
// compile-flags: -Z trait-solver=chalk
trait Foo: Sized { }
trait Bar {
type Item: Foo;
}
impl Foo for i32 { }
impl Foo for str { }
//~^ ERROR the size for values of type `str` cannot be known at compilation time
// Implicit `T: Sized` bound.
impl<T> Foo for Option<T> { }
trait Baz<U: ?Sized> where U: Foo { }
impl Baz<i32> for i32 { }
impl Baz<f32> for f32 { }
//~^ ERROR the trait bound `f32: Foo` is not satisfied
fn main() {
}

29
tests/ui/chalkify/impl_wf.stderr
View file

@ -1,29 +0,0 @@
error[E0277]: the size for values of type `str` cannot be known at compilation time
--> $DIR/impl_wf.rs:11:14
|
LL | impl Foo for str { }
| ^^^ doesn't have a size known at compile-time
|
= help: the trait `Sized` is not implemented for `str`
note: required by a bound in `Foo`
--> $DIR/impl_wf.rs:3:12
|
LL | trait Foo: Sized { }
| ^^^^^ required by this bound in `Foo`
error[E0277]: the trait bound `f32: Foo` is not satisfied
--> $DIR/impl_wf.rs:22:19
|
LL | impl Baz<f32> for f32 { }
| ^^^ the trait `Foo` is not implemented for `f32`
|
= help: the trait `Foo` is implemented for `i32`
note: required by a bound in `Baz`
--> $DIR/impl_wf.rs:18:31
|
LL | trait Baz<U: ?Sized> where U: Foo { }
| ^^^ required by this bound in `Baz`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.

33
tests/ui/chalkify/impl_wf_2.rs
View file

@ -1,33 +0,0 @@
// Split out of impl_wf.rs to work around rust aborting compilation early
// compile-flags: -Z trait-solver=chalk
trait Foo: Sized { }
trait Bar {
type Item: Foo;
}
impl Foo for i32 { }
// Implicit `T: Sized` bound.
impl<T> Foo for Option<T> { }
impl Bar for () {
type Item = i32;
}
impl<T> Bar for Option<T> {
type Item = Option<T>;
}
impl Bar for f32 {
type Item = f32;
//~^ ERROR the trait bound `f32: Foo` is not satisfied
}
trait Baz<U: ?Sized> where U: Foo { }
impl Baz<i32> for i32 { }
fn main() {}

16
tests/ui/chalkify/impl_wf_2.stderr
View file

@ -1,16 +0,0 @@
error[E0277]: the trait bound `f32: Foo` is not satisfied
--> $DIR/impl_wf_2.rs:25:17
|
LL | type Item = f32;
| ^^^ the trait `Foo` is not implemented for `f32`
|
= help: the trait `Foo` is implemented for `i32`
note: required by a bound in `Bar::Item`
--> $DIR/impl_wf_2.rs:8:16
|
LL | type Item: Foo;
| ^^^ required by this bound in `Bar::Item`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

42
tests/ui/chalkify/inherent_impl.rs
View file

@ -1,42 +0,0 @@
// run-pass
// compile-flags: -Z trait-solver=chalk
trait Foo { }
impl Foo for i32 { }
struct S<T: Foo> {
x: T,
}
fn only_foo<T: Foo>(_x: &T) { }
impl<T> S<T> {
// Test that we have the correct environment inside an inherent method.
fn dummy_foo(&self) {
only_foo(&self.x)
}
}
trait Bar { }
impl Bar for u32 { }
fn only_bar<T: Bar>() { }
impl<T> S<T> {
// Test that the environment of `dummy_bar` adds up with the environment
// of the inherent impl.
fn dummy_bar<U: Bar>(&self) {
only_foo(&self.x);
only_bar::<U>();
}
}
fn main() {
let s = S {
x: 5,
};
s.dummy_bar::<u32>();
s.dummy_foo();
}

27
tests/ui/chalkify/inherent_impl_min.rs
View file

@ -1,27 +0,0 @@
// run-pass
// compile-flags: -Z trait-solver=chalk
trait Foo { }
impl Foo for i32 { }
struct S<T: Foo> {
x: T,
}
fn only_foo<T: Foo>(_x: &T) { }
impl<T> S<T> {
// Test that we have the correct environment inside an inherent method.
fn dummy_foo(&self) {
only_foo(&self.x)
}
}
fn main() {
let s = S {
x: 5,
};
s.dummy_foo();
}

14
tests/ui/chalkify/lower_env1.rs
View file

@ -1,14 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
#![allow(dead_code)]
trait Foo { }
trait Bar where Self: Foo { }
fn bar<T: Bar + ?Sized>() {
}
fn main() {
}

16
tests/ui/chalkify/lower_env2.rs
View file

@ -1,16 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
#![allow(dead_code)]
trait Foo { }
struct S<'a, T: ?Sized> where T: Foo {
data: &'a T,
}
fn bar<T: Foo>(_x: S<'_, T>) { // note that we have an implicit `T: Sized` bound
}
fn main() {
}

16
tests/ui/chalkify/lower_env3.rs
View file

@ -1,16 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
#![allow(dead_code)]
trait Foo {
fn foo(&self);
}
impl<T> Foo for T where T: Clone {
fn foo(&self) {
}
}
fn main() {
}

17
tests/ui/chalkify/lower_impl.rs
View file

@ -1,17 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
trait Foo { }
impl<T: 'static> Foo for T where T: Iterator<Item = i32> { }
trait Bar {
type Assoc;
}
impl<T> Bar for T where T: Iterator<Item = i32> {
type Assoc = Vec<T>;
}
fn main() {
}

8
tests/ui/chalkify/lower_struct.rs
View file

@ -1,8 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
struct Foo<'a, T> where Box<T>: Clone {
_x: std::marker::PhantomData<&'a T>,
}
fn main() { }

11
tests/ui/chalkify/lower_trait.rs
View file

@ -1,11 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
trait Bar { }
trait Foo<S, T: ?Sized> {
type Assoc: Bar + ?Sized;
}
fn main() {
}

9
tests/ui/chalkify/lower_trait_higher_rank.rs
View file

@ -1,9 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
trait Foo<F: ?Sized> where for<'a> F: Fn(&'a (u8, u16)) -> &'a u8
{
}
fn main() {
}

16
tests/ui/chalkify/lower_trait_where_clause.rs
View file

@ -1,16 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
use std::borrow::Borrow;
trait Foo<'a, 'b, T, U>
where
T: Borrow<U> + ?Sized,
U: ?Sized + 'b,
'a: 'b,
Box<T>:, // NOTE(#53696) this checks an empty list of bounds.
{
}
fn main() {
}

6
tests/ui/chalkify/println.rs
View file

@ -1,6 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
fn main() {
println!("hello");
}

25
tests/ui/chalkify/projection.rs
View file

@ -1,25 +0,0 @@
// run-pass
// compile-flags: -Z trait-solver=chalk
trait Foo { }
trait Bar {
type Item: Foo;
}
impl Foo for i32 { }
impl Bar for i32 {
type Item = i32;
}
fn only_foo<T: Foo>() { }
fn only_bar<T: Bar>() {
// `T` implements `Bar` hence `<T as Bar>::Item` must also implement `Bar`
only_foo::<T::Item>()
}
fn main() {
only_bar::<i32>();
only_foo::<<i32 as Bar>::Item>();
}

30
tests/ui/chalkify/recursive_where_clause_on_type.rs
View file

@ -1,30 +0,0 @@
// FIXME(chalk): should fail, see comments
// check-fail
// compile-flags: -Z trait-solver=chalk
#![feature(trivial_bounds)]
trait Bar {
fn foo();
}
trait Foo: Bar { }
struct S where S: Foo;
impl Foo for S {
}
fn bar<T: Bar>() {
T::foo();
}
fn foo<T: Foo>() {
bar::<T>()
}
fn main() {
// For some reason, the error is duplicated...
foo::<S>() //~ ERROR the type `S` is not well-formed
//~^ ERROR the type `S` is not well-formed
}

14
tests/ui/chalkify/recursive_where_clause_on_type.stderr
View file

@ -1,14 +0,0 @@
error: the type `S` is not well-formed
--> $DIR/recursive_where_clause_on_type.rs:28:11
|
LL | foo::<S>()
| ^
error: the type `S` is not well-formed
--> $DIR/recursive_where_clause_on_type.rs:28:5
|
LL | foo::<S>()
| ^^^^^^^^
error: aborting due to 2 previous errors

19
tests/ui/chalkify/super_trait.rs
View file

@ -1,19 +0,0 @@
// run-pass
// compile-flags: -Z trait-solver=chalk
trait Foo { }
trait Bar: Foo { }
impl Foo for i32 { }
impl Bar for i32 { }
fn only_foo<T: Foo>() { }
fn only_bar<T: Bar>() {
// `T` implements `Bar` hence `T` must also implement `Foo`
only_foo::<T>()
}
fn main() {
only_bar::<i32>()
}

12
tests/ui/chalkify/trait-objects.rs
View file

@ -1,12 +0,0 @@
// check-pass
// compile-flags: -Z trait-solver=chalk
use std::fmt::Display;
fn main() {
let d: &dyn Display = &mut 3;
d.to_string();
(&d).to_string();
let f: &dyn Fn(i32) -> _ = &|x| x + x;
f(2);
}

18
tests/ui/chalkify/trait_implied_bound.rs
View file

@ -1,18 +0,0 @@
// run-pass
// compile-flags: -Z trait-solver=chalk
trait Foo { }
trait Bar<U> where U: Foo { }
impl Foo for i32 { }
impl Bar<i32> for i32 { }
fn only_foo<T: Foo>() { }
fn only_bar<U, T: Bar<U>>() {
only_foo::<U>()
}
fn main() {
only_bar::<i32, i32>()
}

29
tests/ui/chalkify/type_implied_bound.rs
View file

@ -1,29 +0,0 @@
// run-pass
// compile-flags: -Z trait-solver=chalk
trait Eq { }
trait Hash: Eq { }
impl Eq for i32 { }
impl Hash for i32 { }
struct Set<T: Hash> {
_x: T,
}
fn only_eq<T: Eq>() { }
fn take_a_set<T>(_: &Set<T>) {
// `Set<T>` is an input type of `take_a_set`, hence we know that
// `T` must implement `Hash`, and we know in turn that `T` must
// implement `Eq`.
only_eq::<T>()
}
fn main() {
let set = Set {
_x: 5,
};
take_a_set(&set);
}

28
tests/ui/chalkify/type_inference.rs
View file

@ -1,28 +0,0 @@
// compile-flags: -Z trait-solver=chalk
trait Foo { }
impl Foo for i32 { }
trait Bar { }
impl Bar for i32 { }
impl Bar for u32 { }
fn only_foo<T: Foo>(_x: T) { }
fn only_bar<T: Bar>(_x: T) { }
fn main() {
let x = 5.0;
// The only type which implements `Foo` is `i32`, so the chalk trait solver
// is expecting a variable of type `i32`. This behavior differs from the
// old-style trait solver. I guess this will change, that's why I'm
// adding that test.
// FIXME(chalk): order of these two errors is non-deterministic,
// so let's just hide one for now
//only_foo(x); // ERROR the trait bound `f64: Foo` is not satisfied
// Here we have two solutions so we get back the behavior of the old-style
// trait solver.
only_bar(x); //~ ERROR the trait bound `{float}: Bar` is not satisfied
}

20
tests/ui/chalkify/type_inference.stderr
View file

@ -1,20 +0,0 @@
error[E0277]: the trait bound `{float}: Bar` is not satisfied
--> $DIR/type_inference.rs:27:14
|
LL | only_bar(x);
| -------- ^ the trait `Bar` is not implemented for `{float}`
| |
| required by a bound introduced by this call
|
= help: the following other types implement trait `Bar`:
i32
u32
note: required by a bound in `only_bar`
--> $DIR/type_inference.rs:12:16
|
LL | fn only_bar<T: Bar>(_x: T) { }
| ^^^ required by this bound in `only_bar`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

25
tests/ui/chalkify/type_wf.rs
View file

@ -1,25 +0,0 @@
// check-fail
// compile-flags: -Z trait-solver=chalk
trait Foo { }
struct S<T: Foo> {
x: T,
}
impl Foo for i32 { }
impl<T> Foo for Option<T> { }
fn main() {
let s = S {
x: 5,
};
let s = S {
x: 5.0, //~ ERROR the trait bound `{float}: Foo` is not satisfied
};
let s = S {
x: Some(5.0),
};
}

16
tests/ui/chalkify/type_wf.stderr
View file

@ -1,16 +0,0 @@
error[E0277]: the trait bound `{float}: Foo` is not satisfied
--> $DIR/type_wf.rs:19:12
|
LL | x: 5.0,
| ^^^ the trait `Foo` is not implemented for `{float}`
|
= help: the trait `Foo` is implemented for `i32`
note: required by a bound in `S`
--> $DIR/type_wf.rs:6:13
|
LL | struct S<T: Foo> {
| ^^^ required by this bound in `S`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

1
tests/ui/feature-gates/feature-gate-type_alias_impl_trait.rs
View file

@ -1,4 +1,3 @@
// ignore-compare-mode-chalk
// check-pass
#![feature(type_alias_impl_trait)]
use std::fmt::Debug;

1
tests/ui/impl-trait/issue-55872-3.rs
View file

@ -1,5 +1,4 @@
// edition:2018
// ignore-compare-mode-chalk
#![feature(impl_trait_in_assoc_type)]

6
tests/ui/impl-trait/issue-55872-3.stderr
View file

@ -1,8 +1,8 @@
error[E0277]: the trait bound `[async block@$DIR/issue-55872-3.rs:16:9: 16:17]: Copy` is not satisfied
--> $DIR/issue-55872-3.rs:14:20
error[E0277]: the trait bound `[async block@$DIR/issue-55872-3.rs:15:9: 15:17]: Copy` is not satisfied
--> $DIR/issue-55872-3.rs:13:20
|
LL | fn foo<T>() -> Self::E {
| ^^^^^^^ the trait `Copy` is not implemented for `[async block@$DIR/issue-55872-3.rs:16:9: 16:17]`
| ^^^^^^^ the trait `Copy` is not implemented for `[async block@$DIR/issue-55872-3.rs:15:9: 15:17]`
error: aborting due to previous error

1
tests/ui/impl-trait/issues/issue-65581.rs
View file

@ -1,5 +1,4 @@
// check-pass
// ignore-compare-mode-chalk
#![allow(dead_code)]