structured suggestions for elided-lifetimes-in-paths lint

This was a doozy!

We only issue a suggestion when there's just one implicit lifetime,
because there can be situations where there are several (notice how
`elided_path_lifetimes` in librustc/hir/lowering.rs takes a number of
expected lifetimes as an argument), but we don't have an actionable
suggestion to offer (e.g., if there are two implicit lifetimes in a
return type, we hit E0106 "missing lifetime specifiers" as well as
(still) triggering this lint).

This has to do with rust-lang#52041.

Author: zackmdavis

src/librustc/middle/resolve_lifetime.rs

@@ -21,7 +21,7 @@ use hir::map::Map;
 use hir::{GenericArg, GenericParam, ItemLocalId, LifetimeName, ParamName};
 use ty::{self, TyCtxt, GenericParamDefKind};
 
-use errors::DiagnosticBuilder;
+use errors::{Applicability, DiagnosticBuilder};
 use rustc::lint;
 use rustc_data_structures::sync::Lrc;
 use session::Session;
@@ -609,7 +609,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
                         // resolved the same as the `'_` in `&'_ Foo`.
                         //
                         // cc #48468
-                        self.resolve_elided_lifetimes(vec![lifetime], false)
+                        self.resolve_elided_lifetimes(vec![lifetime])
                     }
                     LifetimeName::Param(_) | LifetimeName::Static => {
                         // If the user wrote an explicit name, use that.
@@ -855,7 +855,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
 
     fn visit_lifetime(&mut self, lifetime_ref: &'tcx hir::Lifetime) {
         if lifetime_ref.is_elided() {
-            self.resolve_elided_lifetimes(vec![lifetime_ref], false);
+            self.resolve_elided_lifetimes(vec![lifetime_ref]);
             return;
         }
         if lifetime_ref.is_static() {
@@ -866,10 +866,10 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
     }
 
     fn visit_path(&mut self, path: &'tcx hir::Path, _: ast::NodeId) {
-        for (i, segment) in path.segments.iter().enumerate() {
+        for (i, ref segment) in path.segments.iter().enumerate() {
             let depth = path.segments.len() - i - 1;
             if let Some(ref args) = segment.args {
-                self.visit_segment_args(path.def, depth, args);
+                self.visit_segment_args(path.def, depth, segment.ident, args);
             }
         }
     }
@@ -1667,6 +1667,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
         &mut self,
         def: Def,
         depth: usize,
+        segment_ident: ast::Ident,
         generic_args: &'tcx hir::GenericArgs,
     ) {
         if generic_args.parenthesized {
@@ -1687,9 +1688,12 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                 Some(lt)
             }
             _ => None,
-        }).collect();
+        }).collect::<Vec<_>>();
         if elide_lifetimes {
-            self.resolve_elided_lifetimes(lifetimes, true);
+            self.lint_implicit_lifetimes_in_segment(
+                segment_ident, generic_args, &lifetimes
+            );
+            self.resolve_elided_lifetimes(lifetimes);
         } else {
             lifetimes.iter().for_each(|lt| self.visit_lifetime(lt));
         }
@@ -2066,27 +2070,80 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
         }
     }
 
+    fn lint_implicit_lifetimes_in_segment(&mut self,
+                                          segment_ident: ast::Ident,
+                                          generic_args: &'tcx hir::GenericArgs,
+                                          lifetime_refs: &[&'tcx hir::Lifetime]) {
+        let num_implicit_lifetimes = lifetime_refs.iter()
+            .filter(|lt| lt.name.is_implicit()).count();
+        if num_implicit_lifetimes == 0 {
+            return;
+        }
+
+        let mut err = self.tcx.struct_span_lint_node(
+            lint::builtin::ELIDED_LIFETIMES_IN_PATHS,
+            lifetime_refs[0].id, // FIXME: HirIdify #50928
+            segment_ident.span,
+            &format!("implicit lifetime parameters in types are deprecated"),
+        );
+
+        if num_implicit_lifetimes == 1 {
+            let (replace_span,
+                 suggestion) = if generic_args.args.len() == num_implicit_lifetimes &&
+                generic_args.bindings.is_empty() {
+                    // If there are no (non-implicit) generic args or bindings, our
+                    // suggestion includes the angle brackets
+                    (segment_ident.span.shrink_to_hi(), "<'_>")
+                } else {
+                    // Otherwise—sorry, this is kind of gross—we need to infer the
+                    // replacement point span from the generics that do exist
+                    let mut first_generic_span = None;
+                    for ref arg in &generic_args.args {
+                        match arg {
+                            hir::GenericArg::Lifetime(lt) => {
+                                // Really, this branch shouldn't happen—you can't elide only
+                                // some lifetimes—but the responsibility for catching that
+                                // error lives elsewhere
+                                if !lt.name.is_implicit() {
+                                    first_generic_span = Some(lt.span);
+                                    break;
+                                }
+                            },
+                            hir::GenericArg::Type(ty) => {
+                                first_generic_span = Some(ty.span);
+                                break;
+                            }
+                        }
+                    }
+                    if let None = first_generic_span {
+                        for ref binding in &generic_args.bindings {
+                            first_generic_span = Some(binding.span);
+                            break;
+                        }
+                    }
+                    let replace_span = first_generic_span
+                        .expect("checked earlier that non-implicit args or bindings exist");
+                    (replace_span.shrink_to_lo(), "'_, ")
+                };
+            err.span_suggestion_with_applicability(
+                replace_span,
+                "indicate the anonymous lifetime",
+                suggestion.to_owned(),
+                Applicability::MachineApplicable
+            );
+        }
+        err.emit();
+    }
+
     fn resolve_elided_lifetimes(&mut self,
-                                lifetime_refs: Vec<&'tcx hir::Lifetime>,
-                                deprecate_implicit: bool) {
+                                lifetime_refs: Vec<&'tcx hir::Lifetime>) {
         if lifetime_refs.is_empty() {
             return;
         }
 
         let span = lifetime_refs[0].span;
         let mut late_depth = 0;
         let mut scope = self.scope;
-        if deprecate_implicit && lifetime_refs[0].name.is_implicit() {
-            let mut err = self.tcx.struct_span_lint_node(
-                lint::builtin::ELIDED_LIFETIMES_IN_PATHS,
-                lifetime_refs[0].id, // FIXME: HirIdify #50928
-                span,
-                &format!("implicit lifetime parameters in types are deprecated"),
-            );
-            // FIXME: suggest `'_` (need to take into account whether angle-bracketed
-            // params already exist)
-            err.emit();
-        }
         let error = loop {
             match *scope {
                 // Do not assign any resolution, it will be inferred.

src/test/ui/in-band-lifetimes/elided-lifetimes.fixed

@@ -0,0 +1,45 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// run-rustfix
+// compile-flags: --edition 2018
+
+#![allow(unused)]
+#![deny(elided_lifetimes_in_paths)]
+//~^ NOTE lint level defined here
+
+use std::cell::{RefCell, Ref};
+
+
+struct Foo<'a> { x: &'a u32 }
+
+fn foo(x: &Foo<'_>) {
+    //~^ ERROR implicit lifetime parameters in types are deprecated
+    //~| HELP indicate the anonymous lifetime
+}
+
+fn bar(x: &Foo<'_>) {}
+
+
+struct Wrapped<'a>(&'a str);
+
+fn wrap_gift(gift: &str) -> Wrapped<'_> {
+    //~^ ERROR implicit lifetime parameters in types are deprecated
+    //~| HELP indicate the anonymous lifetime
+    Wrapped(gift)
+}
+
+
+fn main() {
+    let honesty = RefCell::new((4, 'e'));
+    let loyalty: Ref<'_, (u32, char)> = honesty.borrow();
+    //~^ ERROR implicit lifetime parameters in types are deprecated
+    //~| HELP indicate the anonymous lifetime
+}

src/test/ui/in-band-lifetimes/elided-lifetimes.rs

@@ -8,15 +8,38 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// run-rustfix
+// compile-flags: --edition 2018
+
 #![allow(unused)]
 #![deny(elided_lifetimes_in_paths)]
+//~^ NOTE lint level defined here
+
+use std::cell::{RefCell, Ref};
+
 
 struct Foo<'a> { x: &'a u32 }
 
 fn foo(x: &Foo) {
-    //~^ ERROR: implicit lifetime parameters in types are deprecated
+    //~^ ERROR implicit lifetime parameters in types are deprecated
+    //~| HELP indicate the anonymous lifetime
 }
 
 fn bar(x: &Foo<'_>) {}
 
-fn main() {}
+
+struct Wrapped<'a>(&'a str);
+
+fn wrap_gift(gift: &str) -> Wrapped {
+    //~^ ERROR implicit lifetime parameters in types are deprecated
+    //~| HELP indicate the anonymous lifetime
+    Wrapped(gift)
+}
+
+
+fn main() {
+    let honesty = RefCell::new((4, 'e'));
+    let loyalty: Ref<(u32, char)> = honesty.borrow();
+    //~^ ERROR implicit lifetime parameters in types are deprecated
+    //~| HELP indicate the anonymous lifetime
+}

src/test/ui/in-band-lifetimes/elided-lifetimes.stderr

@@ -1,14 +1,26 @@
 error: implicit lifetime parameters in types are deprecated
-  --> $DIR/elided-lifetimes.rs:16:12
+  --> $DIR/elided-lifetimes.rs:23:12
    |
 LL | fn foo(x: &Foo) {
-   |            ^^^
+   |            ^^^- help: indicate the anonymous lifetime: `<'_>`
    |
 note: lint level defined here
-  --> $DIR/elided-lifetimes.rs:12:9
+  --> $DIR/elided-lifetimes.rs:15:9
    |
 LL | #![deny(elided_lifetimes_in_paths)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: implicit lifetime parameters in types are deprecated
+  --> $DIR/elided-lifetimes.rs:33:29
+   |
+LL | fn wrap_gift(gift: &str) -> Wrapped {
+   |                             ^^^^^^^- help: indicate the anonymous lifetime: `<'_>`
+
+error: implicit lifetime parameters in types are deprecated
+  --> $DIR/elided-lifetimes.rs:42:18
+   |
+LL |     let loyalty: Ref<(u32, char)> = honesty.borrow();
+   |                  ^^^ - help: indicate the anonymous lifetime: `'_,`
+
+error: aborting due to 3 previous errors