Emit single error for + use<'_> and don't suggest use<'static>

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -699,10 +699,15 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                 LifetimeName::Param(def_id) => {
                     self.resolve_lifetime_ref(def_id, lt);
                 }
-                LifetimeName::Error => {}
-                LifetimeName::ImplicitObjectLifetimeDefault
-                | LifetimeName::Infer
-                | LifetimeName::Static => {
+                LifetimeName::Infer | LifetimeName::Error => {
+                    // We don't check for explicit `'_` lifetimes because we'll already have an
+                    // explicit error from late resolution explaining `use<'_>` is invalid.
+                    self.tcx.dcx().span_delayed_bug(
+                        lt.ident.span,
+                        "found infer or error lifetime but no prior error",
+                    );
+                }
+                LifetimeName::ImplicitObjectLifetimeDefault | LifetimeName::Static => {
                     self.tcx.dcx().emit_err(errors::BadPreciseCapture {
                         span: lt.ident.span,
                         kind: "lifetime",

compiler/rustc_resolve/src/late.rs

@@ -1117,6 +1117,18 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
 
     fn visit_precise_capturing_arg(&mut self, arg: &'ast PreciseCapturingArg) {
         match arg {
+            PreciseCapturingArg::Lifetime(lt) if lt.ident.name == kw::UnderscoreLifetime => {
+                // We account for `+ use<'_>` explicitly to avoid providing an invalid suggestion
+                // for `+ use<'static>`.
+                let outer_failures = take(&mut self.diag_metadata.current_elision_failures);
+                visit::walk_precise_capturing_arg(self, arg);
+                let elision_failures =
+                    replace(&mut self.diag_metadata.current_elision_failures, outer_failures);
+                if !elision_failures.is_empty() {
+                    self.report_missing_lifetime_specifiers(elision_failures, None, true);
+                }
+                return;
+            }
             // Lower the lifetime regularly; we'll resolve the lifetime and check
             // it's a parameter later on in HIR lowering.
             PreciseCapturingArg::Lifetime(_) => {}
@@ -1877,7 +1889,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             }
         }
         self.record_lifetime_res(lifetime.id, LifetimeRes::Error, elision_candidate);
-        self.report_missing_lifetime_specifiers(vec![missing_lifetime], None);
+        self.report_missing_lifetime_specifiers(vec![missing_lifetime], None, false);
     }
 
     #[instrument(level = "debug", skip(self))]
@@ -2097,7 +2109,11 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                                 LifetimeElisionCandidate::Ignore,
                             );
                         }
-                        self.report_missing_lifetime_specifiers(vec![missing_lifetime], None);
+                        self.report_missing_lifetime_specifiers(
+                            vec![missing_lifetime],
+                            None,
+                            false,
+                        );
                         break;
                     }
                     LifetimeRibKind::Generics { .. } | LifetimeRibKind::ConstParamTy => {}
@@ -2220,7 +2236,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             replace(&mut self.diag_metadata.current_elision_failures, outer_failures);
         if !elision_failures.is_empty() {
             let Err(failure_info) = elision_lifetime else { bug!() };
-            self.report_missing_lifetime_specifiers(elision_failures, Some(failure_info));
+            self.report_missing_lifetime_specifiers(elision_failures, Some(failure_info), false);
         }
     }
 

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -3032,6 +3032,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         &mut self,
         lifetime_refs: Vec<MissingLifetime>,
         function_param_lifetimes: Option<(Vec<MissingLifetime>, Vec<ElisionFnParameter>)>,
+        in_precise_capture: bool,
     ) -> ErrorGuaranteed {
         let num_lifetimes: usize = lifetime_refs.iter().map(|lt| lt.count).sum();
         let spans: Vec<_> = lifetime_refs.iter().map(|lt| lt.span).collect();
@@ -3043,14 +3044,22 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             "missing lifetime specifier{}",
             pluralize!(num_lifetimes)
         );
-        self.add_missing_lifetime_specifiers_label(
-            &mut err,
-            lifetime_refs,
-            function_param_lifetimes,
-        );
+        if in_precise_capture {
+            err.note(
+                "this function's return type specifies a borrowed `use<'_>` with an elided \
+                 lifetime, but the lifetime cannot be derived from the arguments",
+            );
+        } else {
+            self.add_missing_lifetime_specifiers_label(
+                &mut err,
+                lifetime_refs,
+                function_param_lifetimes,
+            );
+        }
         err.emit()
     }
 
+    #[tracing::instrument(skip(self, err), level = "info")]
     fn add_missing_lifetime_specifiers_label(
         &mut self,
         err: &mut Diag<'_>,

tests/ui/impl-trait/precise-capturing/bad-lifetimes.rs

@@ -1,6 +1,5 @@
 fn no_elided_lt() -> impl Sized + use<'_> {}
 //~^ ERROR missing lifetime specifier
-//~| ERROR expected lifetime parameter in `use<...>` precise captures list, found `'_`
 
 fn static_lt() -> impl Sized + use<'static> {}
 //~^ ERROR expected lifetime parameter in `use<...>` precise captures list, found `'static`

tests/ui/impl-trait/precise-capturing/bad-lifetimes.stderr

@@ -2,35 +2,25 @@ error[E0106]: missing lifetime specifier
   --> $DIR/bad-lifetimes.rs:1:39
    |
 LL | fn no_elided_lt() -> impl Sized + use<'_> {}
-   |                                       ^^ expected named lifetime parameter
-   |
-   = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
-help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`, or if you will only have owned values
+   |                                       ^^
    |
-LL | fn no_elided_lt() -> impl Sized + use<'static> {}
-   |                                       ~~~~~~~
+   = note: this function's return type specifies a borrowed `use<'_>` with an elided lifetime, but the lifetime cannot be derived from the arguments
 
 error[E0261]: use of undeclared lifetime name `'missing`
-  --> $DIR/bad-lifetimes.rs:8:37
+  --> $DIR/bad-lifetimes.rs:7:37
    |
 LL | fn missing_lt() -> impl Sized + use<'missing> {}
    |              -                      ^^^^^^^^ undeclared lifetime
    |              |
    |              help: consider introducing lifetime `'missing` here: `<'missing>`
 
-error: expected lifetime parameter in `use<...>` precise captures list, found `'_`
-  --> $DIR/bad-lifetimes.rs:1:39
-   |
-LL | fn no_elided_lt() -> impl Sized + use<'_> {}
-   |                                       ^^
-
 error: expected lifetime parameter in `use<...>` precise captures list, found `'static`
-  --> $DIR/bad-lifetimes.rs:5:36
+  --> $DIR/bad-lifetimes.rs:4:36
    |
 LL | fn static_lt() -> impl Sized + use<'static> {}
    |                                    ^^^^^^^
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0106, E0261.
 For more information about an error, try `rustc --explain E0106`.