Tweak output for mismatched impl item

Detect type parameter that might require lifetime constraint.
Do not name `ReVar`s in expected/found output.
Reword text suggesting to check the lifetimes.

Author: estebank

src/librustc_infer/infer/error_reporting/mod.rs

@@ -993,10 +993,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             s: &mut DiagnosticStyledString,
         ) {
             let mut r = region.to_string();
-            if let ty::RegionKind::ReVar(var) = region {
-                // Show these named, not as `'_` or elide them in "expected/found" notes.
-                r = format!("'z{} ", var.index());
-            } else if r == "'_" {
+            if r == "'_" {
                 r.clear();
             } else {
                 r.push(' ');

src/librustc_infer/infer/error_reporting/nice_region_error/trait_impl_difference.rs

@@ -1,5 +1,6 @@
 //! Error Reporting for `impl` items that do not match the obligations from their `trait`.
 
+use crate::hir;
 use crate::hir::def_id::DefId;
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::infer::lexical_region_resolve::RegionResolutionError;
@@ -40,7 +41,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                                 var_origin.span(),
                                 sub_expected_found.expected,
                                 sub_expected_found.found,
-                                self.tcx().def_span(*trait_item_def_id),
+                                *trait_item_def_id,
                             );
                             return Some(ErrorReported);
                         }
@@ -51,23 +52,56 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         None
     }
 
-    fn emit_err(&self, sp: Span, expected: Ty<'tcx>, found: Ty<'tcx>, impl_sp: Span) {
+    fn emit_err(&self, sp: Span, expected: Ty<'tcx>, found: Ty<'tcx>, trait_def_id: DefId) {
+        let tcx = self.tcx();
+        let trait_sp = self.tcx().def_span(trait_def_id);
         let mut err = self
             .tcx()
             .sess
             .struct_span_err(sp, "`impl` item signature doesn't match `trait` item signature");
         err.span_label(sp, &format!("found {:?}", found));
-        err.span_label(impl_sp, &format!("expected {:?}", expected));
+        err.span_label(trait_sp, &format!("expected {:?}", expected));
+        let trait_fn_sig = tcx.fn_sig(trait_def_id);
+
+        struct AssocTypeFinder(FxHashSet<ty::ParamTy>);
+        impl<'tcx> ty::fold::TypeVisitor<'tcx> for AssocTypeFinder {
+            fn visit_ty(&mut self, ty: Ty<'tcx>) -> bool {
+                debug!("assoc type finder ty {:?} {:?}", ty, ty.kind);
+                match ty.kind {
+                    ty::Param(param) => {
+                        self.0.insert(param);
+                    }
+                    _ => {}
+                }
+                ty.super_visit_with(self)
+            }
+        }
+        let mut visitor = AssocTypeFinder(FxHashSet::default());
+        trait_fn_sig.output().visit_with(&mut visitor);
+
+        if let Some(id) = tcx.hir().as_local_hir_id(trait_def_id) {
+            let parent_id = tcx.hir().get_parent_item(id);
+            let trait_item = tcx.hir().expect_item(parent_id);
+            if let hir::ItemKind::Trait(_, _, generics, _, _) = &trait_item.kind {
+                for param_ty in visitor.0 {
+                    if let Some(generic) = generics.get_named(param_ty.name) {
+                        err.span_label(generic.span, &format!(
+                            "in order for `impl` items to be able to implement the method, this \
+                             type parameter might need a lifetime restriction like `{}: 'a`",
+                            param_ty.name,
+                        ));
+                    }
+                }
+            }
+        }
 
         struct EarlyBoundRegionHighlighter(FxHashSet<DefId>);
         impl<'tcx> ty::fold::TypeVisitor<'tcx> for EarlyBoundRegionHighlighter {
             fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
-                debug!("LateBoundRegionNameCollector visit_region {:?}", r);
                 match *r {
                     ty::ReFree(free) => {
                         self.0.insert(free.scope);
                     }
-
                     ty::ReEarlyBound(bound) => {
                         self.0.insert(bound.def_id);
                     }
@@ -94,12 +128,11 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         }
         if note {
             err.note(
-                "the lifetime requirements from the `trait` could not be fulfilled by the \
-                      `impl`",
+                "the lifetime requirements from the `trait` could not be fulfilled by the `impl`",
             );
             err.help(
-                "consider adding a named lifetime to the `trait` that constrains the item's \
-                      `self` argument, its inputs and its output with it",
+                "verify the lifetime relationships in the `trait` and `impl` between the \
+                 `self` argument, the other inputs and its output",
             );
         }
         err.emit();

src/test/ui/coercion/coerce-mut.rs

@@ -4,7 +4,7 @@ fn main() {
     let x = 0;
     f(&x);
     //~^ ERROR mismatched types
-    //~| expected mutable reference `&'z1 mut i32`
-    //~| found reference `&'z2 {integer}`
+    //~| expected mutable reference `&mut i32`
+    //~| found reference `&{integer}`
     //~| types differ in mutability
 }

src/test/ui/coercion/coerce-mut.stderr

@@ -4,8 +4,8 @@ error[E0308]: mismatched types
 LL |     f(&x);
    |       ^^ types differ in mutability
    |
-   = note: expected mutable reference `&'z1 mut i32`
-                      found reference `&'z2 {integer}`
+   = note: expected mutable reference `&mut i32`
+                      found reference `&{integer}`
 
 error: aborting due to previous error
 

src/test/ui/compare-method/reordered-type-param.stderr

@@ -11,7 +11,7 @@ LL |   fn b<F:Clone,G>(&self, _x: G) -> G { panic!() }
    |        expected type parameter
    |
    = note: expected fn pointer `fn(&E, F) -> F`
-              found fn pointer `fn(&'z0 E, G) -> G`
+              found fn pointer `fn(&E, G) -> G`
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 

src/test/ui/hrtb/hrtb-exists-forall-fn.stderr

@@ -7,7 +7,7 @@ LL |     let _: for<'b> fn(&'b u32) = foo();
    |            expected due to this
    |
    = note: expected fn pointer `for<'b> fn(&'b u32)`
-              found fn pointer `fn(&'z0 u32)`
+              found fn pointer `fn(&u32)`
 
 error: aborting due to previous error
 

src/test/ui/impl-trait/impl-generic-mismatch-ab.stderr

@@ -10,7 +10,7 @@ LL |     fn foo<B: Debug>(&self, a: &impl Debug, b: &B) { }
    |            expected type parameter
    |
    = note: expected fn pointer `fn(&(), &B, &impl Debug)`
-              found fn pointer `fn(&'z0 (), &impl Debug, &B)`
+              found fn pointer `fn(&(), &impl Debug, &B)`
    = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
    = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
 

src/test/ui/impl-trait/trait_type.stderr

@@ -5,7 +5,7 @@ LL |    fn fmt(&self, x: &str) -> () { }
    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability
    |
    = note: expected fn pointer `fn(&MyType, &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error>`
-              found fn pointer `fn(&'z0 MyType, &str)`
+              found fn pointer `fn(&MyType, &str)`
 
 error[E0050]: method `fmt` has 1 parameter but the declaration in trait `std::fmt::Display::fmt` has 2
   --> $DIR/trait_type.rs:12:11

src/test/ui/in-band-lifetimes/mismatched_trait_impl-2.stderr

@@ -10,9 +10,9 @@ LL |     fn deref(&self) -> &Self::Target;
    |     --------------------------------- expected fn(&Struct) -> &(dyn Trait + 'static)
    |
    = note: expected `fn(&Struct) -> &(dyn Trait + 'static)`
-              found `fn(&'z0 Struct) -> &dyn Trait`
+              found `fn(&Struct) -> &dyn Trait`
    = note: the lifetime requirements from the `trait` could not be fulfilled by the `impl`
-   = help: consider adding a named lifetime to the `trait` that constrains the item's `self` argument, its inputs and its output with it
+   = help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output
 
 error: aborting due to previous error
 

src/test/ui/in-band-lifetimes/mismatched_trait_impl.nll.stderr

@@ -9,6 +9,8 @@ LL |     fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 {
    |
    = note: expected `fn(&i32, &'a u32, &u32) -> &'a u32`
               found `fn(&i32, &u32, &u32) -> &u32`
+   = note: the lifetime requirements from the `trait` could not be fulfilled by the `impl`
+   = help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output
 
 error: aborting due to previous error