Rollup of 10 pull requests

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -17,7 +17,7 @@ use rustc_middle::traits::SignatureMismatchData;
 use rustc_middle::traits::select::OverflowError;
 use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
-use rustc_middle::ty::fold::{BottomUpFolder, TypeFolder, TypeSuperFoldable};
+use rustc_middle::ty::fold::{TypeFolder, TypeSuperFoldable};
 use rustc_middle::ty::print::{
     FmtPrinter, Print, PrintTraitPredicateExt as _, PrintTraitRefExt as _,
     with_forced_trimmed_paths,
@@ -1788,22 +1788,18 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         return false;
                     }
 
-                    let cand = self.resolve_vars_if_possible(impl_trait_ref).fold_with(
-                        &mut BottomUpFolder {
-                            tcx: self.tcx,
-                            ty_op: |ty| ty,
-                            lt_op: |lt| lt,
-                            ct_op: |ct| ct.normalize(self.tcx, ty::ParamEnv::empty()),
-                        },
-                    );
-                    if cand.references_error() {
+                    let impl_trait_ref = self.resolve_vars_if_possible(impl_trait_ref);
+                    if impl_trait_ref.references_error() {
                         return false;
                     }
                     err.highlighted_help(vec![
-                        StringPart::normal(format!("the trait `{}` ", cand.print_trait_sugared())),
+                        StringPart::normal(format!(
+                            "the trait `{}` ",
+                            impl_trait_ref.print_trait_sugared()
+                        )),
                         StringPart::highlighted("is"),
                         StringPart::normal(" implemented for `"),
-                        StringPart::highlighted(cand.self_ty().to_string()),
+                        StringPart::highlighted(impl_trait_ref.self_ty().to_string()),
                         StringPart::normal("`"),
                     ]);
 
@@ -1915,15 +1911,18 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let mut impl_candidates: Vec<_> = impl_candidates
             .iter()
             .cloned()
+            .filter(|cand| !cand.trait_ref.references_error())
             .map(|mut cand| {
-                // Fold the consts so that they shows up as, e.g., `10`
-                // instead of `core::::array::{impl#30}::{constant#0}`.
-                cand.trait_ref = cand.trait_ref.fold_with(&mut BottomUpFolder {
-                    tcx: self.tcx,
-                    ty_op: |ty| ty,
-                    lt_op: |lt| lt,
-                    ct_op: |ct| ct.normalize(self.tcx, ty::ParamEnv::empty()),
-                });
+                // Normalize the trait ref in its *own* param-env so
+                // that consts are folded and any trivial projections
+                // are normalized.
+                cand.trait_ref = self
+                    .tcx
+                    .try_normalize_erasing_regions(
+                        self.tcx.param_env(cand.impl_def_id),
+                        cand.trait_ref,
+                    )
+                    .unwrap_or(cand.trait_ref);
                 cand
             })
             .collect();

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -4620,7 +4620,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     format!("&{}{ty}", mutability.prefix_str())
                 }
             }
-            ty::Array(ty, len) if let Some(len) = len.try_eval_target_usize(tcx, param_env) => {
+            ty::Array(ty, len) if let Some(len) = len.try_to_target_usize(tcx) => {
                 if len == 0 {
                     "[]".to_string()
                 } else if self.type_is_copy_modulo_regions(param_env, ty) || len == 1 {

tests/ui/binop/binary-op-suggest-deref.stderr

@@ -303,8 +303,8 @@ LL |     let _ = FOO & (*"Sized".to_string().into_boxed_str());
    |
    = help: the trait `BitAnd<str>` is not implemented for `i32`
    = help: the following other types implement trait `BitAnd<Rhs>`:
-             `&'a i32` implements `BitAnd<i32>`
-             `&i32` implements `BitAnd<&i32>`
+             `&i32` implements `BitAnd<i32>`
+             `&i32` implements `BitAnd`
              `i32` implements `BitAnd<&i32>`
              `i32` implements `BitAnd`
 

tests/ui/binop/binop-mul-i32-f32.stderr

@@ -6,8 +6,8 @@ LL |     x * y
    |
    = help: the trait `Mul<f32>` is not implemented for `i32`
    = help: the following other types implement trait `Mul<Rhs>`:
-             `&'a i32` implements `Mul<i32>`
-             `&i32` implements `Mul<&i32>`
+             `&i32` implements `Mul<i32>`
+             `&i32` implements `Mul`
              `i32` implements `Mul<&i32>`
              `i32` implements `Mul`
 

tests/ui/binop/shift-various-bad-types.stderr

@@ -6,14 +6,14 @@ LL |     22 >> p.char;
    |
    = help: the trait `Shr<char>` is not implemented for `{integer}`
    = help: the following other types implement trait `Shr<Rhs>`:
-             `&'a i128` implements `Shr<i128>`
-             `&'a i128` implements `Shr<i16>`
-             `&'a i128` implements `Shr<i32>`
-             `&'a i128` implements `Shr<i64>`
-             `&'a i128` implements `Shr<i8>`
-             `&'a i128` implements `Shr<isize>`
-             `&'a i128` implements `Shr<u128>`
-             `&'a i128` implements `Shr<u16>`
+             `&i128` implements `Shr<&i16>`
+             `&i128` implements `Shr<&i32>`
+             `&i128` implements `Shr<&i64>`
+             `&i128` implements `Shr<&i8>`
+             `&i128` implements `Shr<&isize>`
+             `&i128` implements `Shr<&u128>`
+             `&i128` implements `Shr<&u16>`
+             `&i128` implements `Shr<&u32>`
            and 568 others
 
 error[E0277]: no implementation for `{integer} >> &str`
@@ -24,14 +24,14 @@ LL |     22 >> p.str;
    |
    = help: the trait `Shr<&str>` is not implemented for `{integer}`
    = help: the following other types implement trait `Shr<Rhs>`:
-             `&'a i128` implements `Shr<i128>`
-             `&'a i128` implements `Shr<i16>`
-             `&'a i128` implements `Shr<i32>`
-             `&'a i128` implements `Shr<i64>`
-             `&'a i128` implements `Shr<i8>`
-             `&'a i128` implements `Shr<isize>`
-             `&'a i128` implements `Shr<u128>`
-             `&'a i128` implements `Shr<u16>`
+             `&i128` implements `Shr<&i16>`
+             `&i128` implements `Shr<&i32>`
+             `&i128` implements `Shr<&i64>`
+             `&i128` implements `Shr<&i8>`
+             `&i128` implements `Shr<&isize>`
+             `&i128` implements `Shr<&u128>`
+             `&i128` implements `Shr<&u16>`
+             `&i128` implements `Shr<&u32>`
            and 568 others
 
 error[E0277]: no implementation for `{integer} >> &Panolpy`
@@ -42,14 +42,14 @@ LL |     22 >> p;
    |
    = help: the trait `Shr<&Panolpy>` is not implemented for `{integer}`
    = help: the following other types implement trait `Shr<Rhs>`:
-             `&'a i128` implements `Shr<i128>`
-             `&'a i128` implements `Shr<i16>`
-             `&'a i128` implements `Shr<i32>`
-             `&'a i128` implements `Shr<i64>`
-             `&'a i128` implements `Shr<i8>`
-             `&'a i128` implements `Shr<isize>`
-             `&'a i128` implements `Shr<u128>`
-             `&'a i128` implements `Shr<u16>`
+             `&i128` implements `Shr<&i16>`
+             `&i128` implements `Shr<&i32>`
+             `&i128` implements `Shr<&i64>`
+             `&i128` implements `Shr<&i8>`
+             `&i128` implements `Shr<&isize>`
+             `&i128` implements `Shr<&u128>`
+             `&i128` implements `Shr<&u16>`
+             `&i128` implements `Shr<&u32>`
            and 568 others
 
 error[E0308]: mismatched types

tests/ui/const-generics/occurs-check/unused-substs-1.stderr

@@ -4,7 +4,7 @@ error[E0277]: the trait bound `A<_>: Bar<_>` is not satisfied
 LL |     let _ = A;
    |             ^ the trait `Bar<_>` is not implemented for `A<_>`
    |
-   = help: the trait `Bar<_>` is implemented for `A<7>`
+   = help: the trait `Bar<_>` is implemented for `A<{ 6 + 1 }>`
 note: required by a bound in `A`
   --> $DIR/unused-substs-1.rs:9:11
    |

tests/ui/consts/const-eval/const-eval-overflow-3b.stderr

@@ -12,8 +12,8 @@ LL |     = [0; (i8::MAX + 1u8) as usize];
    |
    = help: the trait `Add<u8>` is not implemented for `i8`
    = help: the following other types implement trait `Add<Rhs>`:
-             `&'a i8` implements `Add<i8>`
-             `&i8` implements `Add<&i8>`
+             `&i8` implements `Add<i8>`
+             `&i8` implements `Add`
              `i8` implements `Add<&i8>`
              `i8` implements `Add`
 

tests/ui/consts/const-eval/const-eval-overflow-4b.stderr

@@ -12,8 +12,8 @@ LL |     : [u32; (i8::MAX as i8 + 1u8) as usize]
    |
    = help: the trait `Add<u8>` is not implemented for `i8`
    = help: the following other types implement trait `Add<Rhs>`:
-             `&'a i8` implements `Add<i8>`
-             `&i8` implements `Add<&i8>`
+             `&i8` implements `Add<i8>`
+             `&i8` implements `Add`
              `i8` implements `Add<&i8>`
              `i8` implements `Add`
 

tests/ui/impl-trait/equality.stderr

@@ -30,8 +30,8 @@ LL |         n + sum_to(n - 1)
    |
    = help: the trait `Add<impl Foo>` is not implemented for `u32`
    = help: the following other types implement trait `Add<Rhs>`:
-             `&'a u32` implements `Add<u32>`
-             `&u32` implements `Add<&u32>`
+             `&u32` implements `Add<u32>`
+             `&u32` implements `Add`
              `u32` implements `Add<&u32>`
              `u32` implements `Add`
 

tests/ui/issues/issue-11771.stderr

@@ -6,14 +6,14 @@ LL |     1 +
    |
    = help: the trait `Add<()>` is not implemented for `{integer}`
    = help: the following other types implement trait `Add<Rhs>`:
-             `&'a f128` implements `Add<f128>`
-             `&'a f16` implements `Add<f16>`
-             `&'a f32` implements `Add<f32>`
-             `&'a f64` implements `Add<f64>`
-             `&'a i128` implements `Add<i128>`
-             `&'a i16` implements `Add<i16>`
-             `&'a i32` implements `Add<i32>`
-             `&'a i64` implements `Add<i64>`
+             `&f128` implements `Add<f128>`
+             `&f128` implements `Add`
+             `&f16` implements `Add<f16>`
+             `&f16` implements `Add`
+             `&f32` implements `Add<f32>`
+             `&f32` implements `Add`
+             `&f64` implements `Add<f64>`
+             `&f64` implements `Add`
            and 56 others
 
 error[E0277]: cannot add `()` to `{integer}`
@@ -24,14 +24,14 @@ LL |     1 +
    |
    = help: the trait `Add<()>` is not implemented for `{integer}`
    = help: the following other types implement trait `Add<Rhs>`:
-             `&'a f128` implements `Add<f128>`
-             `&'a f16` implements `Add<f16>`
-             `&'a f32` implements `Add<f32>`
-             `&'a f64` implements `Add<f64>`
-             `&'a i128` implements `Add<i128>`
-             `&'a i16` implements `Add<i16>`
-             `&'a i32` implements `Add<i32>`
-             `&'a i64` implements `Add<i64>`
+             `&f128` implements `Add<f128>`
+             `&f128` implements `Add`
+             `&f16` implements `Add<f16>`
+             `&f16` implements `Add`
+             `&f32` implements `Add<f32>`
+             `&f32` implements `Add`
+             `&f64` implements `Add<f64>`
+             `&f64` implements `Add`
            and 56 others
 
 error: aborting due to 2 previous errors

tests/ui/issues/issue-24352.stderr

@@ -6,8 +6,8 @@ LL |     1.0f64 - 1
    |
    = help: the trait `Sub<{integer}>` is not implemented for `f64`
    = help: the following other types implement trait `Sub<Rhs>`:
-             `&'a f64` implements `Sub<f64>`
-             `&f64` implements `Sub<&f64>`
+             `&f64` implements `Sub<f64>`
+             `&f64` implements `Sub`
              `f64` implements `Sub<&f64>`
              `f64` implements `Sub`
 help: consider using a floating-point literal by writing it with `.0`

tests/ui/issues/issue-50582.stderr

@@ -16,14 +16,14 @@ LL |     Vec::<[(); 1 + for x in 0..1 {}]>::new();
    |
    = help: the trait `Add<()>` is not implemented for `{integer}`
    = help: the following other types implement trait `Add<Rhs>`:
-             `&'a f128` implements `Add<f128>`
-             `&'a f16` implements `Add<f16>`
-             `&'a f32` implements `Add<f32>`
-             `&'a f64` implements `Add<f64>`
-             `&'a i128` implements `Add<i128>`
-             `&'a i16` implements `Add<i16>`
-             `&'a i32` implements `Add<i32>`
-             `&'a i64` implements `Add<i64>`
+             `&f128` implements `Add<f128>`
+             `&f128` implements `Add`
+             `&f16` implements `Add<f16>`
+             `&f16` implements `Add`
+             `&f32` implements `Add<f32>`
+             `&f32` implements `Add`
+             `&f64` implements `Add<f64>`
+             `&f64` implements `Add`
            and 56 others
 
 error: aborting due to 2 previous errors

tests/ui/iterators/invalid-iterator-chain-fixable.stderr

@@ -33,7 +33,7 @@ LL |     println!("{}", scores.sum::<i32>());
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
    = help: the following other types implement trait `Sum<A>`:
-             `i32` implements `Sum<&'a i32>`
+             `i32` implements `Sum<&i32>`
              `i32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain-fixable.rs:14:10
@@ -66,7 +66,7 @@ LL |             .sum::<i32>(),
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
    = help: the following other types implement trait `Sum<A>`:
-             `i32` implements `Sum<&'a i32>`
+             `i32` implements `Sum<&i32>`
              `i32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain-fixable.rs:23:14
@@ -99,7 +99,7 @@ LL |     println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
    = help: the following other types implement trait `Sum<A>`:
-             `i32` implements `Sum<&'a i32>`
+             `i32` implements `Sum<&i32>`
              `i32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain-fixable.rs:27:38

tests/ui/iterators/invalid-iterator-chain-with-int-infer.stderr

@@ -8,7 +8,7 @@ LL |     let x = Some(()).iter().map(|()| 1).sum::<f32>();
    |
    = help: the trait `Sum<{integer}>` is not implemented for `f32`
    = help: the following other types implement trait `Sum<A>`:
-             `f32` implements `Sum<&'a f32>`
+             `f32` implements `Sum<&f32>`
              `f32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain-with-int-infer.rs:2:29

tests/ui/iterators/invalid-iterator-chain.stderr

@@ -33,7 +33,7 @@ LL |     println!("{}", scores.sum::<i32>());
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
    = help: the following other types implement trait `Sum<A>`:
-             `i32` implements `Sum<&'a i32>`
+             `i32` implements `Sum<&i32>`
              `i32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain.rs:12:10
@@ -65,7 +65,7 @@ LL |             .sum::<i32>(),
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
    = help: the following other types implement trait `Sum<A>`:
-             `i32` implements `Sum<&'a i32>`
+             `i32` implements `Sum<&i32>`
              `i32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain.rs:25:14
@@ -104,7 +104,7 @@ LL |             .sum::<i32>(),
    |
    = help: the trait `Sum<f64>` is not implemented for `i32`
    = help: the following other types implement trait `Sum<A>`:
-             `i32` implements `Sum<&'a i32>`
+             `i32` implements `Sum<&i32>`
              `i32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain.rs:33:14
@@ -134,7 +134,7 @@ LL |     println!("{}", vec![0, 1].iter().map(|x| { x; }).sum::<i32>());
    |
    = help: the trait `Sum<()>` is not implemented for `i32`
    = help: the following other types implement trait `Sum<A>`:
-             `i32` implements `Sum<&'a i32>`
+             `i32` implements `Sum<&i32>`
              `i32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain.rs:38:38
@@ -162,7 +162,7 @@ LL |     println!("{}", vec![(), ()].iter().sum::<i32>());
    |
    = help: the trait `Sum<&()>` is not implemented for `i32`
    = help: the following other types implement trait `Sum<A>`:
-             `i32` implements `Sum<&'a i32>`
+             `i32` implements `Sum<&i32>`
              `i32` implements `Sum`
 note: the method call chain might not have had the expected associated types
   --> $DIR/invalid-iterator-chain.rs:39:33

tests/ui/lazy-type-alias/trailing-where-clause.stderr

@@ -9,7 +9,7 @@ LL |     let _: Alias<()>;
              `String` implements `From<&mut str>`
              `String` implements `From<&str>`
              `String` implements `From<Box<str>>`
-             `String` implements `From<Cow<'a, str>>`
+             `String` implements `From<Cow<'_, str>>`
              `String` implements `From<char>`
 note: required by a bound in `Alias`
   --> $DIR/trailing-where-clause.rs:8:13