Improve error message when opaque type is not fully constrained

Author: Aaron1011

src/librustc_typeck/collect.rs

@@ -1617,11 +1617,18 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
                     ty::Param(_) => true,
                     _ => false,
                 };
-                if !substs.types().all(is_param) {
-                    self.tcx.sess.span_err(
-                        span,
-                        "defining opaque type use does not fully define opaque type",
-                    );
+                let bad_substs: Vec<_> = substs.types().enumerate()
+                    .filter(|(_, ty)| !is_param(ty)).collect();
+                if !bad_substs.is_empty() {
+                    let identity_substs = InternalSubsts::identity_for_item(self.tcx, self.def_id);
+                    for (i, bad_subst) in bad_substs {
+                        self.tcx.sess.span_err(
+                            span,
+                            &format!("defining opaque type use does not fully define opaque type: \
+                            generic parameter `{}` is specified as concrete type `{}`",
+                            identity_substs.type_at(i), bad_subst)
+                        );
+                    }
                 } else if let Some((prev_span, prev_ty, ref prev_indices)) = self.found {
                     let mut ty = concrete_type.walk().fuse();
                     let mut p_ty = prev_ty.walk().fuse();

src/test/ui/type-alias-impl-trait/bound_reduction2.stderr

@@ -1,4 +1,4 @@
-error: defining opaque type use does not fully define opaque type
+error: defining opaque type use does not fully define opaque type: generic parameter `V` is specified as concrete type `<T as TraitWithAssoc>::Assoc`
   --> $DIR/bound_reduction2.rs:17:1
    |
 LL | / fn foo_desugared<T: TraitWithAssoc>(_: T) -> Foo<T::Assoc> {

src/test/ui/type-alias-impl-trait/generic_nondefining_use.stderr

@@ -4,7 +4,7 @@ error: at least one trait must be specified
 LL | type Cmp<T> = impl 'static;
    |               ^^^^^^^^^^^^
 
-error: defining opaque type use does not fully define opaque type
+error: defining opaque type use does not fully define opaque type: generic parameter `T` is specified as concrete type `u32`
   --> $DIR/generic_nondefining_use.rs:11:1
    |
 LL | / fn cmp() -> Cmp<u32> {

src/test/ui/type-alias-impl-trait/issue-58887.rs

@@ -1,3 +1,5 @@
+// run-pass
+
 #![feature(type_alias_impl_trait)]
 
 trait UnwrapItemsExt {
@@ -11,11 +13,8 @@ where
     E: std::fmt::Debug,
 {
     type Iter = impl Iterator<Item = T>;
-    //~^ ERROR: could not find defining uses
 
     fn unwrap_items(self) -> Self::Iter {
-    //~^ ERROR: type parameter `T` is part of concrete type
-    //~| ERROR: type parameter `E` is part of concrete type
         self.map(|x| x.unwrap())
     }
 }

src/test/ui/type-alias-impl-trait/issue-58887.stderr

@@ -18,7 +18,7 @@ where
 {
     type BitsIter = IterBitsIter<T, E, u8>;
     fn iter_bits(self, n: u8) -> Self::BitsIter {
-    //~^ ERROR type parameter `E` is part of concrete type but not used
+    //~^ ERROR defining opaque type use does not fully define opaque typ
         (0u8..n)
             .rev()
             .map(move |shift| ((self >> T::from(shift)) & T::from(1)).try_into().unwrap())

src/test/ui/type-alias-impl-trait/issue-60564.rs

@@ -1,8 +1,7 @@
-error: type parameter `E` is part of concrete type but not used in parameter list for the `impl Trait` type alias
-  --> $DIR/issue-60564.rs:20:49
+error: defining opaque type use does not fully define opaque type: generic parameter `I` is specified as concrete type `u8`
+  --> $DIR/issue-60564.rs:20:5
    |
-LL |       fn iter_bits(self, n: u8) -> Self::BitsIter {
-   |  _________________________________________________^
+LL | /     fn iter_bits(self, n: u8) -> Self::BitsIter {
 LL | |
 LL | |         (0u8..n)
 LL | |             .rev()

src/test/ui/type-alias-impl-trait/issue-60564.stderr

@@ -1,4 +1,4 @@
-error: defining opaque type use does not fully define opaque type
+error: defining opaque type use does not fully define opaque type: generic parameter `U` is specified as concrete type `u32`
   --> $DIR/not_a_defining_use.rs:9:1
    |
 LL | / fn two<T: Debug>(t: T) -> Two<T, u32> {