Make the error for opaque types that have no hidden types a bit informative

oli-obk · oli-obk · commit 29c873243688 · 2022-02-02T15:40:12.000Z
diff --git a/compiler/rustc_typeck/src/collect/type_of.rs b/compiler/rustc_typeck/src/collect/type_of.rs
@@ -724,7 +724,12 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> {
         Some((_, ty)) => ty,
         None => {
             let span = tcx.def_span(def_id);
-            tcx.sess.span_err(span, "could not find defining uses");
+            let name = tcx.item_name(tcx.parent(def_id.to_def_id()).unwrap());
+            let label = format!(
+                "`{}` must be used in combination with a concrete type within the same module",
+                name
+            );
+            tcx.sess.struct_span_err(span, "unconstrained opaque type").note(&label).emit();
             tcx.ty_error()
         }
     }
diff --git a/src/test/ui/generic-associated-types/issue-87258_a.rs b/src/test/ui/generic-associated-types/issue-87258_a.rs
@@ -16,7 +16,7 @@ pub trait Trait2 {
 
 impl<'c, S: Trait2> Trait2 for &'c mut S {
     type FooFuture<'a> = impl Trait1;
-    //~^ ERROR could not find defining uses
+    //~^ ERROR unconstrained opaque type
     fn foo<'a>() -> Self::FooFuture<'a> {
         Struct(unimplemented!())
     }
diff --git a/src/test/ui/generic-associated-types/issue-87258_a.stderr b/src/test/ui/generic-associated-types/issue-87258_a.stderr
@@ -1,8 +1,10 @@
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/issue-87258_a.rs:18:26
    |
 LL |     type FooFuture<'a> = impl Trait1;
    |                          ^^^^^^^^^^^
+   |
+   = note: `FooFuture` must be used in combination with a concrete type within the same module
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/generic-associated-types/issue-87258_b.rs b/src/test/ui/generic-associated-types/issue-87258_b.rs
@@ -15,7 +15,7 @@ pub trait Trait2 {
 }
 
 type Helper<'xenon, 'yttrium, KABOOM: Trait2> = impl Trait1;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 
 impl<'c, S: Trait2> Trait2 for &'c mut S {
     type FooFuture<'a> = Helper<'c, 'a, S>;
diff --git a/src/test/ui/generic-associated-types/issue-87258_b.stderr b/src/test/ui/generic-associated-types/issue-87258_b.stderr
@@ -1,8 +1,10 @@
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/issue-87258_b.rs:17:49
    |
 LL | type Helper<'xenon, 'yttrium, KABOOM: Trait2> = impl Trait1;
    |                                                 ^^^^^^^^^^^
+   |
+   = note: `Helper` must be used in combination with a concrete type within the same module
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/generic-associated-types/issue-88595.rs b/src/test/ui/generic-associated-types/issue-88595.rs
@@ -18,7 +18,7 @@ struct C;
 impl<'a> A<'a> for C {
     type B<'b> = impl Clone;
     //~^ ERROR: lifetime bound not satisfied
-    //~| ERROR: could not find defining uses
+    //~| ERROR: unconstrained opaque type
 
     fn a(&'a self) -> Self::B<'a> {} //~ ERROR: non-defining opaque type use in defining scope
 }
diff --git a/src/test/ui/generic-associated-types/issue-88595.stderr b/src/test/ui/generic-associated-types/issue-88595.stderr
@@ -29,11 +29,13 @@ LL | impl<'a> A<'a> for C {
 LL |     type B<'b> = impl Clone;
    |            ^^
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/issue-88595.rs:19:18
    |
 LL |     type B<'b> = impl Clone;
    |                  ^^^^^^^^^^
+   |
+   = note: `B` must be used in combination with a concrete type within the same module
 
 error: aborting due to 3 previous errors
 
diff --git a/src/test/ui/impl-trait/recursive-type-alias-impl-trait-declaration-too-subtle.rs b/src/test/ui/impl-trait/recursive-type-alias-impl-trait-declaration-too-subtle.rs
@@ -2,7 +2,7 @@
 
 mod a {
     type Foo = impl PartialEq<(Foo, i32)>;
-    //~^ ERROR could not find defining uses
+    //~^ ERROR unconstrained opaque type
 
     struct Bar;
 
@@ -15,7 +15,7 @@ mod a {
 
 mod b {
     type Foo = impl PartialEq<(Foo, i32)>;
-    //~^ ERROR could not find defining uses
+    //~^ ERROR unconstrained opaque type
 
     struct Bar;
 
diff --git a/src/test/ui/impl-trait/recursive-type-alias-impl-trait-declaration-too-subtle.stderr b/src/test/ui/impl-trait/recursive-type-alias-impl-trait-declaration-too-subtle.stderr
@@ -1,14 +1,18 @@
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/recursive-type-alias-impl-trait-declaration-too-subtle.rs:4:16
    |
 LL |     type Foo = impl PartialEq<(Foo, i32)>;
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Foo` must be used in combination with a concrete type within the same module
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/recursive-type-alias-impl-trait-declaration-too-subtle.rs:17:16
    |
 LL |     type Foo = impl PartialEq<(Foo, i32)>;
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Foo` must be used in combination with a concrete type within the same module
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/impl-trait/two_tait_defining_each_other2.rs b/src/test/ui/impl-trait/two_tait_defining_each_other2.rs
@@ -1,7 +1,7 @@
 #![feature(type_alias_impl_trait)]
 
 type A = impl Foo;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 type B = impl Foo;
 
 trait Foo {}
diff --git a/src/test/ui/impl-trait/two_tait_defining_each_other2.stderr b/src/test/ui/impl-trait/two_tait_defining_each_other2.stderr
@@ -1,8 +1,10 @@
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/two_tait_defining_each_other2.rs:3:10
    |
 LL | type A = impl Foo;
    |          ^^^^^^^^
+   |
+   = note: `A` must be used in combination with a concrete type within the same module
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/lint/inline-trait-and-foreign-items.rs b/src/test/ui/lint/inline-trait-and-foreign-items.rs
@@ -23,7 +23,7 @@ impl Trait for () {
     type T = Self;
 
     #[inline] //~ ERROR attribute should be applied to function or closure
-    type U = impl Trait; //~ ERROR could not find defining uses
+    type U = impl Trait; //~ ERROR unconstrained opaque type
 }
 
 extern "C" {
diff --git a/src/test/ui/lint/inline-trait-and-foreign-items.stderr b/src/test/ui/lint/inline-trait-and-foreign-items.stderr
@@ -61,11 +61,13 @@ LL |     #[inline]
 LL |     type T;
    |     ------- not a function or closure
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/inline-trait-and-foreign-items.rs:26:14
    |
 LL |     type U = impl Trait;
    |              ^^^^^^^^^^
+   |
+   = note: `U` must be used in combination with a concrete type within the same module
 
 error: aborting due to 6 previous errors; 2 warnings emitted
 
diff --git a/src/test/ui/never_type/impl_trait_fallback3.rs b/src/test/ui/never_type/impl_trait_fallback3.rs
@@ -7,7 +7,7 @@ trait T {
 }
 
 type Foo = impl T;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 
 fn a() -> Foo {
     // This is not a defining use, it doesn't actually constrain the opaque type.
diff --git a/src/test/ui/never_type/impl_trait_fallback3.stderr b/src/test/ui/never_type/impl_trait_fallback3.stderr
@@ -1,8 +1,10 @@
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/impl_trait_fallback3.rs:9:12
    |
 LL | type Foo = impl T;
    |            ^^^^^^
+   |
+   = note: `Foo` must be used in combination with a concrete type within the same module
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/save-analysis/issue-68621.rs b/src/test/ui/save-analysis/issue-68621.rs
@@ -11,7 +11,7 @@ trait Service {
 struct Struct;
 
 impl Service for Struct {
-    type Future = impl Trait; //~ ERROR: could not find defining uses
+    type Future = impl Trait; //~ ERROR: unconstrained opaque type
 }
 
 fn main() {}
diff --git a/src/test/ui/save-analysis/issue-68621.stderr b/src/test/ui/save-analysis/issue-68621.stderr
@@ -1,8 +1,10 @@
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/issue-68621.rs:14:19
    |
 LL |     type Future = impl Trait;
    |                   ^^^^^^^^^^
+   |
+   = note: `Future` must be used in combination with a concrete type within the same module
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/type-alias-impl-trait/bound_reduction2.rs b/src/test/ui/type-alias-impl-trait/bound_reduction2.rs
@@ -7,7 +7,7 @@ trait TraitWithAssoc {
 }
 
 type Foo<V> = impl Trait<V>;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 
 trait Trait<U> {}
 
diff --git a/src/test/ui/type-alias-impl-trait/bound_reduction2.stderr b/src/test/ui/type-alias-impl-trait/bound_reduction2.stderr
@@ -10,11 +10,13 @@ note: used non-generic type `<T as TraitWithAssoc>::Assoc` for generic parameter
 LL | type Foo<V> = impl Trait<V>;
    |          ^
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/bound_reduction2.rs:9:15
    |
 LL | type Foo<V> = impl Trait<V>;
    |               ^^^^^^^^^^^^^
+   |
+   = note: `Foo` must be used in combination with a concrete type within the same module
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/type-alias-impl-trait/bounds-are-checked.rs b/src/test/ui/type-alias-impl-trait/bounds-are-checked.rs
@@ -4,7 +4,7 @@
 #![feature(type_alias_impl_trait)]
 
 type X<'a> = impl Into<&'static str> + From<&'a str>;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 
 fn f<'a: 'static>(t: &'a str) -> X<'a> {
     //~^ WARNING unnecessary lifetime parameter
diff --git a/src/test/ui/type-alias-impl-trait/bounds-are-checked.stderr b/src/test/ui/type-alias-impl-trait/bounds-are-checked.stderr
@@ -15,11 +15,13 @@ LL | type X<'a> = impl Into<&'static str> + From<&'a str>;
 LL |     t
    |     ^
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/bounds-are-checked.rs:6:14
    |
 LL | type X<'a> = impl Into<&'static str> + From<&'a str>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `X` must be used in combination with a concrete type within the same module
 
 error: aborting due to 2 previous errors; 1 warning emitted
 
diff --git a/src/test/ui/type-alias-impl-trait/declared_but_never_defined.rs b/src/test/ui/type-alias-impl-trait/declared_but_never_defined.rs
@@ -3,4 +3,4 @@
 fn main() {}
 
 // declared but never defined
-type Bar = impl std::fmt::Debug; //~ ERROR could not find defining uses
+type Bar = impl std::fmt::Debug; //~ ERROR unconstrained opaque type
diff --git a/src/test/ui/type-alias-impl-trait/declared_but_never_defined.stderr b/src/test/ui/type-alias-impl-trait/declared_but_never_defined.stderr
@@ -1,8 +1,10 @@
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/declared_but_never_defined.rs:6:12
    |
 LL | type Bar = impl std::fmt::Debug;
    |            ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Bar` must be used in combination with a concrete type within the same module
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.rs b/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.rs
@@ -4,7 +4,7 @@ fn main() {}
 
 mod boo {
     // declared in module but not defined inside of it
-    pub type Boo = impl ::std::fmt::Debug; //~ ERROR could not find defining uses
+    pub type Boo = impl ::std::fmt::Debug; //~ ERROR unconstrained opaque type
 }
 
 fn bomp() -> boo::Boo {
diff --git a/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.stderr b/src/test/ui/type-alias-impl-trait/declared_but_not_defined_in_scope.stderr
@@ -1,8 +1,10 @@
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/declared_but_not_defined_in_scope.rs:7:20
    |
 LL |     pub type Boo = impl ::std::fmt::Debug;
    |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Boo` must be used in combination with a concrete type within the same module
 
 error[E0308]: mismatched types
   --> $DIR/declared_but_not_defined_in_scope.rs:11:5
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.rs
@@ -3,7 +3,7 @@
 fn main() {}
 
 type Two<'a, 'b> = impl std::fmt::Debug;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 
 fn one<'a>(t: &'a ()) -> Two<'a, 'a> {
     t
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_lifetime_param.stderr
@@ -10,11 +10,13 @@ note: lifetime used multiple times
 LL | type Two<'a, 'b> = impl std::fmt::Debug;
    |          ^^  ^^
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/generic_duplicate_lifetime_param.rs:5:20
    |
 LL | type Two<'a, 'b> = impl std::fmt::Debug;
    |                    ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `Two` must be used in combination with a concrete type within the same module
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use.rs
@@ -6,11 +6,11 @@ fn main() {}
 
 // test that unused generic parameters are ok
 type TwoTys<T, U> = impl Debug;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 type TwoLifetimes<'a, 'b> = impl Debug;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 type TwoConsts<const X: usize, const Y: usize> = impl Debug;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 
 fn one_ty<T: Debug>(t: T) -> TwoTys<T, T> {
     t
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use.stderr
@@ -10,11 +10,13 @@ note: type used multiple times
 LL | type TwoTys<T, U> = impl Debug;
    |             ^  ^
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/generic_duplicate_param_use.rs:8:21
    |
 LL | type TwoTys<T, U> = impl Debug;
    |                     ^^^^^^^^^^
+   |
+   = note: `TwoTys` must be used in combination with a concrete type within the same module
 
 error: non-defining opaque type use in defining scope
   --> $DIR/generic_duplicate_param_use.rs:21:5
@@ -28,11 +30,13 @@ note: lifetime used multiple times
 LL | type TwoLifetimes<'a, 'b> = impl Debug;
    |                   ^^  ^^
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/generic_duplicate_param_use.rs:10:29
    |
 LL | type TwoLifetimes<'a, 'b> = impl Debug;
    |                             ^^^^^^^^^^
+   |
+   = note: `TwoLifetimes` must be used in combination with a concrete type within the same module
 
 error: non-defining opaque type use in defining scope
   --> $DIR/generic_duplicate_param_use.rs:26:5
@@ -46,11 +50,13 @@ note: constant used multiple times
 LL | type TwoConsts<const X: usize, const Y: usize> = impl Debug;
    |                      ^               ^
 
-error: could not find defining uses
+error: unconstrained opaque type
   --> $DIR/generic_duplicate_param_use.rs:12:50
    |
 LL | type TwoConsts<const X: usize, const Y: usize> = impl Debug;
    |                                                  ^^^^^^^^^^
+   |
+   = note: `TwoConsts` must be used in combination with a concrete type within the same module
 
 error: aborting due to 6 previous errors
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_nondefining_use.rs b/src/test/ui/type-alias-impl-trait/generic_nondefining_use.rs
@@ -5,11 +5,11 @@ use std::fmt::Debug;
 fn main() {}
 
 type OneTy<T> = impl Debug;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 type OneLifetime<'a> = impl Debug;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 type OneConst<const X: usize> = impl Debug;
-//~^ ERROR could not find defining uses
+//~^ ERROR unconstrained opaque type
 
 // Not defining uses, because they doesn't define *all* possible generics.
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_nondefining_use.stderr b/src/test/ui/type-alias-impl-trait/generic_nondefining_use.stderr
diff --git a/src/test/ui/type-alias-impl-trait/issue-60564.rs b/src/test/ui/type-alias-impl-trait/issue-60564.rs
diff --git a/src/test/ui/type-alias-impl-trait/issue-60564.stderr b/src/test/ui/type-alias-impl-trait/issue-60564.stderr
diff --git a/src/test/ui/type-alias-impl-trait/issue-68368-non-defining-use-2.rs b/src/test/ui/type-alias-impl-trait/issue-68368-non-defining-use-2.rs
diff --git a/src/test/ui/type-alias-impl-trait/issue-68368-non-defining-use-2.stderr b/src/test/ui/type-alias-impl-trait/issue-68368-non-defining-use-2.stderr
diff --git a/src/test/ui/type-alias-impl-trait/issue-68368-non-defining-use.rs b/src/test/ui/type-alias-impl-trait/issue-68368-non-defining-use.rs
diff --git a/src/test/ui/type-alias-impl-trait/issue-68368-non-defining-use.stderr b/src/test/ui/type-alias-impl-trait/issue-68368-non-defining-use.stderr
diff --git a/src/test/ui/type-alias-impl-trait/nested-tait-inference3.rs b/src/test/ui/type-alias-impl-trait/nested-tait-inference3.rs
diff --git a/src/test/ui/type-alias-impl-trait/nested-tait-inference3.stderr b/src/test/ui/type-alias-impl-trait/nested-tait-inference3.stderr
diff --git a/src/test/ui/type-alias-impl-trait/no_inferrable_concrete_type.rs b/src/test/ui/type-alias-impl-trait/no_inferrable_concrete_type.rs
diff --git a/src/test/ui/type-alias-impl-trait/no_inferrable_concrete_type.stderr b/src/test/ui/type-alias-impl-trait/no_inferrable_concrete_type.stderr
diff --git a/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.rs
diff --git a/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error.stderr
diff --git a/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.rs b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.rs
diff --git a/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr b/src/test/ui/type-alias-impl-trait/type-alias-impl-trait-with-cycle-error2.stderr

Original file line number	Diff line number	Diff line change
`@@ -724,7 +724,12 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> {`
`724`	`724`	`Some((_, ty)) => ty,`
`725`	`725`	`None => {`
`726`	`726`	`let span = tcx.def_span(def_id);`
`727`		`- tcx.sess.span_err(span, "could not find defining uses");`
	`727`	`+ let name = tcx.item_name(tcx.parent(def_id.to_def_id()).unwrap());`
	`728`	`+ let label = format!(`
	`729`	+ "`{}` must be used in combination with a concrete type within the same module",
	`730`	`+ name`
	`731`	`+ );`
	`732`	`+ tcx.sess.struct_span_err(span, "unconstrained opaque type").note(&label).emit();`
`728`	`733`	`tcx.ty_error()`
`729`	`734`	`}`
`730`	`735`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ pub trait Trait2 {`
`16`	`16`
`17`	`17`	`impl<'c, S: Trait2> Trait2 for &'c mut S {`
`18`	`18`	`type FooFuture<'a> = impl Trait1;`
`19`		`- //~^ ERROR could not find defining uses`
	`19`	`+ //~^ ERROR unconstrained opaque type`
`20`	`20`	`fn foo<'a>() -> Self::FooFuture<'a> {`
`21`	`21`	`Struct(unimplemented!())`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ pub trait Trait2 {`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`type Helper<'xenon, 'yttrium, KABOOM: Trait2> = impl Trait1;`
`18`		`-//~^ ERROR could not find defining uses`
	`18`	`+//~^ ERROR unconstrained opaque type`
`19`	`19`
`20`	`20`	`impl<'c, S: Trait2> Trait2 for &'c mut S {`
`21`	`21`	`type FooFuture<'a> = Helper<'c, 'a, S>;`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ struct C;`
`18`	`18`	`impl<'a> A<'a> for C {`
`19`	`19`	`type B<'b> = impl Clone;`
`20`	`20`	`//~^ ERROR: lifetime bound not satisfied`
`21`		`- //~\| ERROR: could not find defining uses`
	`21`	`+ //~\| ERROR: unconstrained opaque type`
`22`	`22`
`23`	`23`	`fn a(&'a self) -> Self::B<'a> {} //~ ERROR: non-defining opaque type use in defining scope`
`24`	`24`	`}`