Bless test fallout

Author: compiler-errors

compiler/rustc_trait_selection/src/error_reporting/infer/region.rs

@@ -17,8 +17,8 @@ use rustc_span::{BytePos, ErrorGuaranteed, Span, Symbol};
 use rustc_type_ir::Upcast as _;
 
 use super::nice_region_error::find_anon_type;
-use super::{nice_region_error, ObligationCauseAsDiagArg};
-use crate::error_reporting::infer::ObligationCauseExt as _;
+use super::ObligationCauseAsDiagArg;
+use crate::error_reporting::infer::ObligationCauseExt;
 use crate::error_reporting::TypeErrCtxt;
 use crate::errors::{
     self, note_and_explain, FulfillReqLifetime, LfBoundNotSatisfied, OutlivesBound,
@@ -1212,22 +1212,8 @@ pub fn unexpected_hidden_region_diagnostic<'a, 'tcx>(
                 hidden_region,
                 "",
             );
-            if let Some(reg_info) = tcx.is_suitable_region(generic_param_scope, hidden_region) {
-                if infcx.tcx.features().precise_capturing {
-                    suggest_precise_capturing(tcx, opaque_ty_key.def_id, hidden_region, &mut err);
-                } else {
-                    let fn_returns = tcx.return_type_impl_or_dyn_traits(reg_info.def_id);
-                    nice_region_error::suggest_new_region_bound(
-                        tcx,
-                        &mut err,
-                        fn_returns,
-                        hidden_region.to_string(),
-                        None,
-                        format!("captures `{hidden_region}`"),
-                        None,
-                        Some(reg_info.def_id),
-                    )
-                }
+            if let Some(_) = tcx.is_suitable_region(generic_param_scope, hidden_region) {
+                suggest_precise_capturing(tcx, opaque_ty_key.def_id, hidden_region, &mut err);
             }
         }
         ty::RePlaceholder(_) => {

tests/ui/async-await/multiple-lifetimes/ret-impl-trait-one.stderr

@@ -26,10 +26,10 @@ LL | |     (a, b)
 LL | | }
    | |_^
    |
-help: to declare that `impl Trait<'a>` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | async fn async_ret_impl_trait1<'a, 'b>(a: &'a u8, b: &'b u8) -> impl Trait<'a> + 'b {
-   |                                                                                ++++
+LL | async fn async_ret_impl_trait1<'a, 'b>(a: &'a u8, b: &'b u8) -> impl Trait<'a> + use<'a, 'b> {
+   |                                                                                +++++++++++++
 
 error: aborting due to 2 previous errors
 

tests/ui/borrowck/alias-liveness/opaque-type-param.stderr

@@ -7,6 +7,11 @@ LL | fn foo<'a>(s: &'a str) -> impl Trait + 'static {
    |        hidden type `impl Trait + 'static` captures the lifetime `'a` as defined here
 LL |     bar(s)
    |     ^^^^^^
+   |
+help: add a `use<...>` bound to explicitly capture `'a`
+   |
+LL | fn foo<'a>(s: &'a str) -> impl Trait + 'static + use<'a> {
+   |                                                +++++++++
 
 error: aborting due to 1 previous error
 

tests/ui/const-generics/generic_const_exprs/issue-109141.stderr

@@ -30,10 +30,10 @@ LL |     fn a(&self) -> impl Iterator {
 LL |         self.0.iter_mut()
    |         ^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Iterator` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL |     fn a(&self) -> impl Iterator + '_ {
-   |                                  ++++
+LL |     fn a(&self) -> impl Iterator + use<'_> {
+   |                                  +++++++++
 
 error: aborting due to 3 previous errors
 

tests/ui/feature-gates/feature-gate-lifetime-capture-rules-2024.stderr

@@ -8,10 +8,10 @@ LL | fn foo(x: &Vec<i32>) -> impl Sized {
 LL |     x
    |     ^
    |
-help: to declare that `impl Sized` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL | fn foo(x: &Vec<i32>) -> impl Sized + '_ {
-   |                                    ++++
+LL | fn foo(x: &Vec<i32>) -> impl Sized + use<'_> {
+   |                                    +++++++++
 
 error: aborting due to 1 previous error
 

tests/ui/impl-trait/alias-liveness/rpit-hidden-erased-unsoundness.stderr

@@ -8,10 +8,10 @@ LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a {
 LL |     step1::<'a, 'b>()
    |     ^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Sized + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a + 'b {
-   |                                           ++++
+LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a + use<'a, 'b> {
+   |                                           +++++++++++++
 
 error: aborting due to 1 previous error
 

tests/ui/impl-trait/alias-liveness/rpit-hide-lifetime-for-swap.stderr

@@ -8,10 +8,10 @@ LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a {
 LL |     x
    |     ^
    |
-help: to declare that `impl Swap + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + 'b {
-   |                                                                          ++++
+LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + use<'a, 'b, T> {
+   |                                                                          ++++++++++++++++
 
 error: aborting due to 1 previous error
 

tests/ui/impl-trait/hidden-lifetimes.stderr

@@ -8,10 +8,10 @@ LL | fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a {
 LL |     x
    |     ^
    |
-help: to declare that `impl Swap + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a + 'b {
-   |                                                                     ++++
+LL | fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a + use<'a, 'b, T> {
+   |                                                                     ++++++++++++++++
 
 error[E0700]: hidden type for `impl Swap + 'a` captures lifetime that does not appear in bounds
   --> $DIR/hidden-lifetimes.rs:46:5
@@ -23,10 +23,10 @@ LL | fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl S
 LL |     x
    |     ^
    |
-help: to declare that `impl Swap + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + 'b {
-   |                                                                                     ++++
+LL | fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + use<'a, 'b, T> {
+   |                                                                                     ++++++++++++++++
 
 error: aborting due to 2 previous errors
 

tests/ui/impl-trait/in-trait/cannot-capture-intersection.rs

@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 use std::future::Future;
 use std::pin::Pin;
 

tests/ui/impl-trait/in-trait/cannot-capture-intersection.stderr

@@ -1,5 +1,5 @@
 error[E0700]: hidden type for `impl Future<Output = i32>` captures lifetime that does not appear in bounds
-  --> $DIR/cannot-capture-intersection.rs:24:9
+  --> $DIR/cannot-capture-intersection.rs:22:9
    |
 LL |     fn foo<'a, 'b>(&'a self, x: &'b i32) -> impl Future<Output = i32> {
    |                                             ------------------------- opaque type defined here