Rollup merge of #126620 - oli-obk:taint_errors, r=fee1-dead

Actually taint InferCtxt when a fulfillment error is emitted

And avoid checking the global error counter

fixes #122044
fixes #123255
fixes #123276
fixes #125799

42 files changed, 595 insertions, 238 deletions

diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index b206d8046ee..a188c1b12ae 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -119,16 +119,7 @@ where
 
     let errors = wfcx.select_all_or_error();
     if !errors.is_empty() {
-        let err = infcx.err_ctxt().report_fulfillment_errors(errors);
-        if tcx.dcx().has_errors().is_some() {
-            return Err(err);
-        } else {
-            // HACK(oli-obk): tests/ui/specialization/min_specialization/specialize_on_type_error.rs
-            // causes an delayed bug during normalization, without reporting an error, so we need
-            // to act as if no error happened, in order to let our callers continue and report an
-            // error later in check_impl_items_against_trait.
-            return Ok(());
-        }
+        return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
     }
 
     debug!(?assumed_wf_types);
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index b67d29fce92..2714be1f9b4 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -793,7 +793,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
     }
 
     fn report_error(&self, p: impl Into<ty::GenericArg<'tcx>>) -> ErrorGuaranteed {
-        if let Some(guar) = self.fcx.dcx().has_errors() {
+        if let Some(guar) = self.fcx.tainted_by_errors() {
             guar
         } else {
             self.fcx
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
index 038f11c60b8..33074c20f57 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -2776,97 +2776,115 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                 let mut this = "this bound";
                 let mut note = None;
                 let mut help = None;
-                if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder()
-                    && let ty::ClauseKind::Trait(trait_pred) = clause
-                {
-                    let def_id = trait_pred.def_id();
-                    let visible_item = if let Some(local) = def_id.as_local() {
-                        // Check for local traits being reachable.
-                        let vis = &tcx.resolutions(()).effective_visibilities;
-                        // Account for non-`pub` traits in the root of the local crate.
-                        let is_locally_reachable = tcx.parent(def_id).is_crate_root();
-                        vis.is_reachable(local) || is_locally_reachable
-                    } else {
-                        // Check for foreign traits being reachable.
-                        tcx.visible_parent_map(()).get(&def_id).is_some()
-                    };
-                    if tcx.is_lang_item(def_id, LangItem::Sized) {
-                        // Check if this is an implicit bound, even in foreign crates.
-                        if tcx
-                            .generics_of(item_def_id)
-                            .own_params
-                            .iter()
-                            .any(|param| tcx.def_span(param.def_id) == span)
-                        {
-                            a = "an implicit `Sized`";
-                            this = "the implicit `Sized` requirement on this type parameter";
-                        }
-                        if let Some(hir::Node::TraitItem(hir::TraitItem {
-                            generics,
-                            kind: hir::TraitItemKind::Type(bounds, None),
-                            ..
-                        })) = tcx.hir().get_if_local(item_def_id)
-                        // Do not suggest relaxing if there is an explicit `Sized` obligation.
-                        && !bounds.iter()
-                            .filter_map(|bound| bound.trait_ref())
-                            .any(|tr| tr.trait_def_id() == tcx.lang_items().sized_trait())
-                        {
-                            let (span, separator) = if let [.., last] = bounds {
-                                (last.span().shrink_to_hi(), " +")
+                if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder() {
+                    match clause {
+                        ty::ClauseKind::Trait(trait_pred) => {
+                            let def_id = trait_pred.def_id();
+                            let visible_item = if let Some(local) = def_id.as_local() {
+                                // Check for local traits being reachable.
+                                let vis = &tcx.resolutions(()).effective_visibilities;
+                                // Account for non-`pub` traits in the root of the local crate.
+                                let is_locally_reachable = tcx.parent(def_id).is_crate_root();
+                                vis.is_reachable(local) || is_locally_reachable
                             } else {
-                                (generics.span.shrink_to_hi(), ":")
+                                // Check for foreign traits being reachable.
+                                tcx.visible_parent_map(()).get(&def_id).is_some()
                             };
-                            err.span_suggestion_verbose(
-                                span,
-                                "consider relaxing the implicit `Sized` restriction",
-                                format!("{separator} ?Sized"),
-                                Applicability::MachineApplicable,
-                            );
+                            if tcx.is_lang_item(def_id, LangItem::Sized) {
+                                // Check if this is an implicit bound, even in foreign crates.
+                                if tcx
+                                    .generics_of(item_def_id)
+                                    .own_params
+                                    .iter()
+                                    .any(|param| tcx.def_span(param.def_id) == span)
+                                {
+                                    a = "an implicit `Sized`";
+                                    this =
+                                        "the implicit `Sized` requirement on this type parameter";
+                                }
+                                if let Some(hir::Node::TraitItem(hir::TraitItem {
+                                    generics,
+                                    kind: hir::TraitItemKind::Type(bounds, None),
+                                    ..
+                                })) = tcx.hir().get_if_local(item_def_id)
+                                    // Do not suggest relaxing if there is an explicit `Sized` obligation.
+                                    && !bounds.iter()
+                                        .filter_map(|bound| bound.trait_ref())
+                                        .any(|tr| tr.trait_def_id() == tcx.lang_items().sized_trait())
+                                {
+                                    let (span, separator) = if let [.., last] = bounds {
+                                        (last.span().shrink_to_hi(), " +")
+                                    } else {
+                                        (generics.span.shrink_to_hi(), ":")
+                                    };
+                                    err.span_suggestion_verbose(
+                                        span,
+                                        "consider relaxing the implicit `Sized` restriction",
+                                        format!("{separator} ?Sized"),
+                                        Applicability::MachineApplicable,
+                                    );
+                                }
+                            }
+                            if let DefKind::Trait = tcx.def_kind(item_def_id)
+                                && !visible_item
+                            {
+                                note = Some(format!(
+                                    "`{short_item_name}` is a \"sealed trait\", because to implement it \
+                                    you also need to implement `{}`, which is not accessible; this is \
+                                    usually done to force you to use one of the provided types that \
+                                    already implement it",
+                                    with_no_trimmed_paths!(tcx.def_path_str(def_id)),
+                                ));
+                                let impls_of = tcx.trait_impls_of(def_id);
+                                let impls = impls_of
+                                    .non_blanket_impls()
+                                    .values()
+                                    .flatten()
+                                    .chain(impls_of.blanket_impls().iter())
+                                    .collect::<Vec<_>>();
+                                if !impls.is_empty() {
+                                    let len = impls.len();
+                                    let mut types = impls
+                                        .iter()
+                                        .map(|t| {
+                                            with_no_trimmed_paths!(format!(
+                                                "  {}",
+                                                tcx.type_of(*t).instantiate_identity(),
+                                            ))
+                                        })
+                                        .collect::<Vec<_>>();
+                                    let post = if types.len() > 9 {
+                                        types.truncate(8);
+                                        format!("\nand {} others", len - 8)
+                                    } else {
+                                        String::new()
+                                    };
+                                    help = Some(format!(
+                                        "the following type{} implement{} the trait:\n{}{post}",
+                                        pluralize!(len),
+                                        if len == 1 { "s" } else { "" },
+                                        types.join("\n"),
+                                    ));
+                                }
+                            }
                         }
-                    }
-                    if let DefKind::Trait = tcx.def_kind(item_def_id)
-                        && !visible_item
-                    {
-                        note = Some(format!(
-                            "`{short_item_name}` is a \"sealed trait\", because to implement it \
-                             you also need to implement `{}`, which is not accessible; this is \
-                             usually done to force you to use one of the provided types that \
-                             already implement it",
-                            with_no_trimmed_paths!(tcx.def_path_str(def_id)),
-                        ));
-                        let impls_of = tcx.trait_impls_of(def_id);
-                        let impls = impls_of
-                            .non_blanket_impls()
-                            .values()
-                            .flatten()
-                            .chain(impls_of.blanket_impls().iter())
-                            .collect::<Vec<_>>();
-                        if !impls.is_empty() {
-                            let len = impls.len();
-                            let mut types = impls
-                                .iter()
-                                .map(|t| {
-                                    with_no_trimmed_paths!(format!(
-                                        "  {}",
-                                        tcx.type_of(*t).instantiate_identity(),
-                                    ))
-                                })
-                                .collect::<Vec<_>>();
-                            let post = if types.len() > 9 {
-                                types.truncate(8);
-                                format!("\nand {} others", len - 8)
+                        ty::ClauseKind::ConstArgHasType(..) => {
+                            let descr =
+                                format!("required by a const generic parameter in `{item_name}`");
+                            if span.is_visible(sm) {
+                                let msg = format!(
+                                    "required by this const generic parameter in `{short_item_name}`"
+                                );
+                                multispan.push_span_label(span, msg);
+                                err.span_note(multispan, descr);
                             } else {
-                                String::new()
-                            };
-                            help = Some(format!(
-                                "the following type{} implement{} the trait:\n{}{post}",
-                                pluralize!(len),
-                                if len == 1 { "s" } else { "" },
-                                types.join("\n"),
-                            ));
+                                err.span_note(tcx.def_span(item_def_id), descr);
+                            }
+                            return;
                         }
+                        _ => (),
                     }
-                };
+                }
                 let descr = format!("required by {a} bound in `{item_name}`");
                 if span.is_visible(sm) {
                     let msg = format!("required by {this} in `{short_item_name}`");
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
index e38f7951197..b5f2d34852f 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
@@ -179,6 +179,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             for (error, suppressed) in iter::zip(&errors, &is_suppressed) {
                 if !suppressed && error.obligation.cause.span.from_expansion() == from_expansion {
                     let guar = self.report_fulfillment_error(error);
+                    self.infcx.set_tainted_by_errors(guar);
                     reported = Some(guar);
                     // We want to ignore desugarings here: spans are equivalent even
                     // if one is the result of a desugaring and the other is not.
@@ -2686,22 +2687,14 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                 }
             }
 
-            // Given some `ConstArgHasType(?x, usize)`, we should not emit an error such as
-            // "type annotations needed: cannot satisfy the constant `_` has type `usize`"
-            // Instead we should emit a normal error suggesting the user to turbofish the
-            // const parameter that is currently being inferred. Unfortunately we cannot
-            // nicely emit such an error so we delay an ICE incase nobody else reports it
-            // for us.
-            ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, ty)) => {
-                return self.tcx.sess.dcx().span_delayed_bug(
+            ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, ..)) => self
+                .emit_inference_failure_err(
+                    obligation.cause.body_id,
                     span,
-                    format!(
-                        "`ambiguous ConstArgHasType({:?}, {:?}) unaccompanied by inference error`",
-                        ct, ty
-                    ),
-                );
-            }
-
+                    ct.into(),
+                    ErrorCode::E0284,
+                    true,
+                ),
             ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term })
                 if term.is_infer() =>
             {
diff --git a/tests/crashes/122044.rs b/tests/crashes/122044.rs
deleted file mode 100644
index 4c1d0de5719..00000000000
--- a/tests/crashes/122044.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//@ known-bug: #122044
-use std::hint::black_box;
-
-trait Func {
-    type Ret: Id;
-}
-
-trait Id {
-    type Assoc;
-}
-impl Id for u32 {}
-impl Id for u32 {}
-
-impl<F: FnOnce() -> R, R: Id> Func for F {
-    type Ret = R;
-}
-
-fn bar() -> impl Copy + Id {
-    0u32
-}
-
-struct Foo<T: Func> {
-    _func: T,
-    value: Option<<<T as Func>::Ret as Id>::Assoc>,
-}
-
-fn main() {
-    let mut fn_def = black_box(Foo {
-        _func: bar,
-        value: None,
-    });
-    let fn_ptr = black_box(Foo {
-        _func: bar as fn() -> _,
-        value: None,
-    });
-
-    fn_def.value = fn_ptr.value;
-}
diff --git a/tests/crashes/123255.rs b/tests/crashes/123255.rs
deleted file mode 100644
index a94a2a0422e..00000000000
--- a/tests/crashes/123255.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: rust-lang/rust#123255
-//@ edition:2021
-#![crate_type = "lib"]
-
-pub fn a() {}
-
-mod handlers {
-    pub struct C(&());
-    pub fn c() -> impl Fn() -> C {
-        let a1 = ();
-        || C((crate::a(), a1).into())
-    }
-}
diff --git a/tests/incremental/const-generics/issue-64087.rs b/tests/incremental/const-generics/issue-64087.rs
index 97f212b3fbb..787f2af8aa3 100644
--- a/tests/incremental/const-generics/issue-64087.rs
+++ b/tests/incremental/const-generics/issue-64087.rs
@@ -6,4 +6,6 @@ fn combinator<T, const S: usize>() -> [T; S] {}
 fn main() {
     combinator().into_iter();
     //[cfail1]~^ ERROR type annotations needed
+    //[cfail1]~| ERROR type annotations needed
+    //[cfail1]~| ERROR type annotations needed
 }
diff --git a/tests/ui/const-generics/defaults/doesnt_infer.rs b/tests/ui/const-generics/defaults/doesnt_infer.rs
index 016685eee9d..f62088210fe 100644
--- a/tests/ui/const-generics/defaults/doesnt_infer.rs
+++ b/tests/ui/const-generics/defaults/doesnt_infer.rs
@@ -12,4 +12,5 @@ fn main() {
     let foo = Foo::<1>::foo();
     let foo = Foo::foo();
     //~^ ERROR type annotations needed for `Foo<_>`
+    //~| ERROR type annotations needed
 }
diff --git a/tests/ui/const-generics/defaults/doesnt_infer.stderr b/tests/ui/const-generics/defaults/doesnt_infer.stderr
index 1e779f75ce0..c17f57f36bc 100644
--- a/tests/ui/const-generics/defaults/doesnt_infer.stderr
+++ b/tests/ui/const-generics/defaults/doesnt_infer.stderr
@@ -1,14 +1,37 @@
-error[E0282]: type annotations needed for `Foo<_>`
+error[E0284]: type annotations needed for `Foo<_>`
   --> $DIR/doesnt_infer.rs:13:9
    |
 LL |     let foo = Foo::foo();
-   |         ^^^
+   |         ^^^   ---------- type must be known at this point
    |
+note: required by a const generic parameter in `Foo::<N>::foo`
+  --> $DIR/doesnt_infer.rs:5:6
+   |
+LL | impl<const N: u32> Foo<N> {
+   |      ^^^^^^^^^^^^ required by this const generic parameter in `Foo::<N>::foo`
+LL |     fn foo() -> Self {
+   |        --- required by a bound in this associated function
+help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified
+   |
+LL |     let foo: Foo<N> = Foo::foo();
+   |            ++++++++
+
+error[E0284]: type annotations needed for `Foo<_>`
+  --> $DIR/doesnt_infer.rs:13:9
+   |
+LL |     let foo = Foo::foo();
+   |         ^^^   --- type must be known at this point
+   |
+note: required by a const generic parameter in `Foo`
+  --> $DIR/doesnt_infer.rs:3:12
+   |
+LL | struct Foo<const N: u32 = 2>;
+   |            ^^^^^^^^^^^^^^^^ required by this const generic parameter in `Foo`
 help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified
    |
 LL |     let foo: Foo<N> = Foo::foo();
    |            ++++++++
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/defaults/rp_impl_trait_fail.stderr b/tests/ui/const-generics/defaults/rp_impl_trait_fail.stderr
index 4ed1c0ded9f..45be3126e3b 100644
--- a/tests/ui/const-generics/defaults/rp_impl_trait_fail.stderr
+++ b/tests/ui/const-generics/defaults/rp_impl_trait_fail.stderr
@@ -31,12 +31,17 @@ LL |     1_u64
    |
    = help: the trait `Traitor<1, 2>` is implemented for `u64`
 
-error[E0282]: type annotations needed
+error[E0284]: type annotations needed
   --> $DIR/rp_impl_trait_fail.rs:28:5
    |
 LL |     uwu();
    |     ^^^ cannot infer the value of the const parameter `N` declared on the function `uwu`
    |
+note: required by a const generic parameter in `uwu`
+  --> $DIR/rp_impl_trait_fail.rs:16:8
+   |
+LL | fn uwu<const N: u8>() -> impl Traitor<N> {
+   |        ^^^^^^^^^^^ required by this const generic parameter in `uwu`
 help: consider specifying the generic argument
    |
 LL |     uwu::<N>();
@@ -44,5 +49,5 @@ LL |     uwu::<N>();
 
 error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0277, E0282.
+Some errors have detailed explanations: E0277, E0284.
 For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/generic_arg_infer/issue-91614.rs b/tests/ui/const-generics/generic_arg_infer/issue-91614.rs
index cfbc5faecd9..a386b1e5c2b 100644
--- a/tests/ui/const-generics/generic_arg_infer/issue-91614.rs
+++ b/tests/ui/const-generics/generic_arg_infer/issue-91614.rs
@@ -5,4 +5,5 @@ use std::simd::Mask;
 fn main() {
     let y = Mask::<_, _>::splat(false);
     //~^ ERROR: type annotations needed
+    //~| ERROR type annotations needed
 }
diff --git a/tests/ui/const-generics/generic_arg_infer/issue-91614.stderr b/tests/ui/const-generics/generic_arg_infer/issue-91614.stderr
index 563406ad5ea..217f609459e 100644
--- a/tests/ui/const-generics/generic_arg_infer/issue-91614.stderr
+++ b/tests/ui/const-generics/generic_arg_infer/issue-91614.stderr
@@ -1,23 +1,29 @@
-error[E0283]: type annotations needed for `Mask<_, _>`
+error[E0284]: type annotations needed for `Mask<_, _>`
   --> $DIR/issue-91614.rs:6:9
    |
 LL |     let y = Mask::<_, _>::splat(false);
    |         ^   -------------------------- type must be known at this point
    |
-   = note: cannot satisfy `_: MaskElement`
-   = help: the following types implement trait `MaskElement`:
-             i16
-             i32
-             i64
-             i8
-             isize
-note: required by a bound in `Mask::<T, N>::splat`
+note: required by a const generic parameter in `Mask::<T, N>::splat`
   --> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL
-help: consider giving `y` an explicit type, where the type for type parameter `T` is specified
+help: consider giving `y` an explicit type, where the value of const parameter `N` is specified
    |
 LL |     let y: Mask<T, N> = Mask::<_, _>::splat(false);
    |          ++++++++++++
 
-error: aborting due to 1 previous error
+error[E0284]: type annotations needed for `Mask<_, _>`
+  --> $DIR/issue-91614.rs:6:9
+   |
+LL |     let y = Mask::<_, _>::splat(false);
+   |         ^   ------------ type must be known at this point
+   |
+note: required by a const generic parameter in `Mask`
+  --> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL
+help: consider giving `y` an explicit type, where the value of const parameter `N` is specified
+   |
+LL |     let y: Mask<T, N> = Mask::<_, _>::splat(false);
+   |          ++++++++++++
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0283`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-62504.full.stderr b/tests/ui/const-generics/generic_const_exprs/issue-62504.full.stderr
index 5cda4681b5c..3739637c279 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-62504.full.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-62504.full.stderr
@@ -18,18 +18,41 @@ help: try adding a `where` bound
 LL |     pub const fn new() -> Self where [(); Self::SIZE]: {
    |                                +++++++++++++++++++++++
 
-error[E0282]: type annotations needed for `ArrayHolder<_>`
+error[E0284]: type annotations needed for `ArrayHolder<_>`
   --> $DIR/issue-62504.rs:26:9
    |
 LL |     let mut array = ArrayHolder::new();
-   |         ^^^^^^^^^
+   |         ^^^^^^^^^   ------------------ type must be known at this point
    |
+note: required by a const generic parameter in `ArrayHolder::<X>::new`
+  --> $DIR/issue-62504.rs:16:6
+   |
+LL | impl<const X: usize> ArrayHolder<X> {
+   |      ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder::<X>::new`
+LL |     pub const fn new() -> Self {
+   |                  --- required by a bound in this associated function
+help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
+   |
+LL |     let mut array: ArrayHolder<X> = ArrayHolder::new();
+   |                  ++++++++++++++++
+
+error[E0284]: type annotations needed for `ArrayHolder<_>`
+  --> $DIR/issue-62504.rs:26:9
+   |
+LL |     let mut array = ArrayHolder::new();
+   |         ^^^^^^^^^   ----------- type must be known at this point
+   |
+note: required by a const generic parameter in `ArrayHolder`
+  --> $DIR/issue-62504.rs:14:20
+   |
+LL | struct ArrayHolder<const X: usize>([u32; X]);
+   |                    ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder`
 help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
    |
 LL |     let mut array: ArrayHolder<X> = ArrayHolder::new();
    |                  ++++++++++++++++
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0282, E0308.
-For more information about an error, try `rustc --explain E0282`.
+Some errors have detailed explanations: E0284, E0308.
+For more information about an error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-62504.min.stderr b/tests/ui/const-generics/generic_const_exprs/issue-62504.min.stderr
index beb159779ff..14c67e2528a 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-62504.min.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-62504.min.stderr
@@ -22,18 +22,41 @@ note: tuple struct defined here
 LL | struct ArrayHolder<const X: usize>([u32; X]);
    |        ^^^^^^^^^^^
 
-error[E0282]: type annotations needed for `ArrayHolder<_>`
+error[E0284]: type annotations needed for `ArrayHolder<_>`
   --> $DIR/issue-62504.rs:26:9
    |
 LL |     let mut array = ArrayHolder::new();
-   |         ^^^^^^^^^
+   |         ^^^^^^^^^   ------------------ type must be known at this point
    |
+note: required by a const generic parameter in `ArrayHolder::<X>::new`
+  --> $DIR/issue-62504.rs:16:6
+   |
+LL | impl<const X: usize> ArrayHolder<X> {
+   |      ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder::<X>::new`
+LL |     pub const fn new() -> Self {
+   |                  --- required by a bound in this associated function
+help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
+   |
+LL |     let mut array: ArrayHolder<X> = ArrayHolder::new();
+   |                  ++++++++++++++++
+
+error[E0284]: type annotations needed for `ArrayHolder<_>`
+  --> $DIR/issue-62504.rs:26:9
+   |
+LL |     let mut array = ArrayHolder::new();
+   |         ^^^^^^^^^   ----------- type must be known at this point
+   |
+note: required by a const generic parameter in `ArrayHolder`
+  --> $DIR/issue-62504.rs:14:20
+   |
+LL | struct ArrayHolder<const X: usize>([u32; X]);
+   |                    ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder`
 help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
    |
 LL |     let mut array: ArrayHolder<X> = ArrayHolder::new();
    |                  ++++++++++++++++
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0282, E0308.
-For more information about an error, try `rustc --explain E0282`.
+Some errors have detailed explanations: E0284, E0308.
+For more information about an error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-62504.rs b/tests/ui/const-generics/generic_const_exprs/issue-62504.rs
index b6a6a277843..f021e103614 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-62504.rs
+++ b/tests/ui/const-generics/generic_const_exprs/issue-62504.rs
@@ -25,4 +25,5 @@ impl<const X: usize> ArrayHolder<X> {
 fn main() {
     let mut array = ArrayHolder::new();
     //~^ ERROR: type annotations needed
+    //~| ERROR type annotations needed
 }
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.rs b/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.rs
index 79e9834b54e..298cfb512e4 100644
--- a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.rs
+++ b/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.rs
@@ -18,4 +18,5 @@ fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized {
 fn main() {
     use_dyn(&());
     //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
 }
diff --git a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr b/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
index e800c5d059f..d1e1c976da6 100644
--- a/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
@@ -4,16 +4,37 @@ error[E0284]: type annotations needed
 LL |     use_dyn(&());
    |     ^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `use_dyn`
    |
-note: required by a bound in `use_dyn`
-  --> $DIR/object-safety-ok-infer-err.rs:14:55
+note: required by a const generic parameter in `use_dyn`
+  --> $DIR/object-safety-ok-infer-err.rs:14:12
    |
 LL | fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized {
-   |                                                       ^^^^^ required by this bound in `use_dyn`
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `use_dyn`
 help: consider specifying the generic argument
    |
 LL |     use_dyn::<N>(&());
    |            +++++
 
-error: aborting due to 1 previous error
+error[E0284]: type annotations needed
+  --> $DIR/object-safety-ok-infer-err.rs:19:5
+   |
+LL |     use_dyn(&());
+   |     ^^^^^^^ --- type must be known at this point
+   |     |
+   |     cannot infer the value of the const parameter `N` declared on the function `use_dyn`
+   |
+note: required for `()` to implement `Foo<_>`
+  --> $DIR/object-safety-ok-infer-err.rs:8:22
+   |
+LL | impl<const N: usize> Foo<N> for () {
+   |      --------------  ^^^^^^     ^^
+   |      |
+   |      unsatisfied trait bound introduced here
+   = note: required for the cast from `&()` to `&dyn Foo<_>`
+help: consider specifying the generic argument
+   |
+LL |     use_dyn::<N>(&());
+   |            +++++
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/infer/cannot-infer-const-args.stderr b/tests/ui/const-generics/infer/cannot-infer-const-args.stderr
index e3caefef10f..c349a50a83f 100644
--- a/tests/ui/const-generics/infer/cannot-infer-const-args.stderr
+++ b/tests/ui/const-generics/infer/cannot-infer-const-args.stderr
@@ -1,9 +1,14 @@
-error[E0282]: type annotations needed
+error[E0284]: type annotations needed
   --> $DIR/cannot-infer-const-args.rs:6:5
    |
 LL |     foo();
    |     ^^^ cannot infer the value of the const parameter `X` declared on the function `foo`
    |
+note: required by a const generic parameter in `foo`
+  --> $DIR/cannot-infer-const-args.rs:1:8
+   |
+LL | fn foo<const X: usize>() -> usize {
+   |        ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
 help: consider specifying the generic argument
    |
 LL |     foo::<X>();
@@ -11,4 +16,4 @@ LL |     foo::<X>();
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/infer/issue-77092.rs b/tests/ui/const-generics/infer/issue-77092.rs
index fcf7d3282b4..47c594e5b11 100644
--- a/tests/ui/const-generics/infer/issue-77092.rs
+++ b/tests/ui/const-generics/infer/issue-77092.rs
@@ -1,14 +1,15 @@
 use std::convert::TryInto;
 
 fn take_array_from_mut<T, const N: usize>(data: &mut [T], start: usize) -> &mut [T; N] {
-    (&mut data[start .. start + N]).try_into().unwrap()
+    (&mut data[start..start + N]).try_into().unwrap()
 }
 
 fn main() {
     let mut arr = [0, 1, 2, 3, 4, 5, 6, 7, 8];
 
-    for i in 1 .. 4 {
+    for i in 1..4 {
         println!("{:?}", take_array_from_mut(&mut arr, i));
         //~^ ERROR type annotations needed
+        //~| ERROR type annotations needed
     }
 }
diff --git a/tests/ui/const-generics/infer/issue-77092.stderr b/tests/ui/const-generics/infer/issue-77092.stderr
index 5b411269862..9a6374a2adc 100644
--- a/tests/ui/const-generics/infer/issue-77092.stderr
+++ b/tests/ui/const-generics/infer/issue-77092.stderr
@@ -1,14 +1,37 @@
-error[E0282]: type annotations needed
+error[E0284]: type annotations needed
   --> $DIR/issue-77092.rs:11:26
    |
 LL |         println!("{:?}", take_array_from_mut(&mut arr, i));
    |                          ^^^^^^^^^^^^^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `take_array_from_mut`
    |
+note: required by a const generic parameter in `take_array_from_mut`
+  --> $DIR/issue-77092.rs:3:27
+   |
+LL | fn take_array_from_mut<T, const N: usize>(data: &mut [T], start: usize) -> &mut [T; N] {
+   |                           ^^^^^^^^^^^^^^ required by this const generic parameter in `take_array_from_mut`
+help: consider specifying the generic arguments
+   |
+LL |         println!("{:?}", take_array_from_mut::<i32, N>(&mut arr, i));
+   |                                             ++++++++++
+
+error[E0284]: type annotations needed
+  --> $DIR/issue-77092.rs:11:26
+   |
+LL |         println!("{:?}", take_array_from_mut(&mut arr, i));
+   |                   ----   ^^^^^^^^^^^^^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `take_array_from_mut`
+   |                   |
+   |                   type must be known at this point
+   |
+   = note: required for `[i32; _]` to implement `Debug`
+   = note: 1 redundant requirement hidden
+   = note: required for `&mut [i32; _]` to implement `Debug`
+note: required by a bound in `core::fmt::rt::Argument::<'a>::new_debug`
+  --> $SRC_DIR/core/src/fmt/rt.rs:LL:COL
 help: consider specifying the generic arguments
    |
 LL |         println!("{:?}", take_array_from_mut::<i32, N>(&mut arr, i));
    |                                             ++++++++++
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/infer/method-chain.stderr b/tests/ui/const-generics/infer/method-chain.stderr
index 2def9e85ab7..95044bb5203 100644
--- a/tests/ui/const-generics/infer/method-chain.stderr
+++ b/tests/ui/const-generics/infer/method-chain.stderr
@@ -1,9 +1,14 @@
-error[E0282]: type annotations needed
+error[E0284]: type annotations needed
   --> $DIR/method-chain.rs:15:33
    |
 LL |     Foo.bar().bar().bar().bar().baz();
    |                                 ^^^ cannot infer the value of the const parameter `N` declared on the method `baz`
    |
+note: required by a const generic parameter in `Foo::baz`
+  --> $DIR/method-chain.rs:8:12
+   |
+LL |     fn baz<const N: usize>(self) -> Foo {
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::baz`
 help: consider specifying the generic argument
    |
 LL |     Foo.bar().bar().bar().bar().baz::<N>();
@@ -11,4 +16,4 @@ LL |     Foo.bar().bar().bar().bar().baz::<N>();
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/infer/one-param-uninferred.stderr b/tests/ui/const-generics/infer/one-param-uninferred.stderr
index 3e33fec9cef..f3aa7973e67 100644
--- a/tests/ui/const-generics/infer/one-param-uninferred.stderr
+++ b/tests/ui/const-generics/infer/one-param-uninferred.stderr
@@ -1,9 +1,14 @@
-error[E0282]: type annotations needed
+error[E0284]: type annotations needed
   --> $DIR/one-param-uninferred.rs:9:23
    |
 LL |     let _: [u8; 17] = foo();
    |                       ^^^ cannot infer the value of the const parameter `M` declared on the function `foo`
    |
+note: required by a const generic parameter in `foo`
+  --> $DIR/one-param-uninferred.rs:2:24
+   |
+LL | fn foo<const N: usize, const M: usize>() -> [u8; N] {
+   |                        ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
 help: consider specifying the generic arguments
    |
 LL |     let _: [u8; 17] = foo::<17, M>();
@@ -11,4 +16,4 @@ LL |     let _: [u8; 17] = foo::<17, M>();
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/const-generics/infer/uninferred-consts.rs b/tests/ui/const-generics/infer/uninferred-consts.rs
index 657f4b51304..552e2a15c23 100644
--- a/tests/ui/const-generics/infer/uninferred-consts.rs
+++ b/tests/ui/const-generics/infer/uninferred-consts.rs
@@ -8,4 +8,5 @@ impl Foo {
 fn main() {
     Foo.foo();
     //~^ ERROR type annotations needed
+    //~| ERROR type annotations needed
 }
diff --git a/tests/ui/const-generics/infer/uninferred-consts.stderr b/tests/ui/const-generics/infer/uninferred-consts.stderr
index 0ec6ac9c22e..839fb25c4e1 100644
--- a/tests/ui/const-generics/infer/uninferred-consts.stderr
+++ b/tests/ui/const-generics/infer/uninferred-consts.stderr
@@ -1,14 +1,35 @@
-error[E0282]: type annotations needed
+error[E0284]: type annotations needed
   --> $DIR/uninferred-consts.rs:9:9
    |
 LL |     Foo.foo();
    |         ^^^ cannot infer the value of the const parameter `A` declared on the method `foo`
    |
+note: required by a const generic parameter in `Foo::foo`
+  --> $DIR/uninferred-consts.rs:6:12
+   |
+LL |     fn foo<const A: usize, const B: usize>(self) {}
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::foo`
+help: consider specifying the generic arguments
+   |
+LL |     Foo.foo::<A, B>();
+   |            ++++++++
+
+error[E0284]: type annotations needed
+  --> $DIR/uninferred-consts.rs:9:9
+   |
+LL |     Foo.foo();
+   |         ^^^ cannot infer the value of the const parameter `B` declared on the method `foo`
+   |
+note: required by a const generic parameter in `Foo::foo`
+  --> $DIR/uninferred-consts.rs:6:28
+   |
+LL |     fn foo<const A: usize, const B: usize>(self) {}
+   |                            ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::foo`
 help: consider specifying the generic arguments
    |
 LL |     Foo.foo::<A, B>();
    |            ++++++++
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/crashes/125799.rs b/tests/ui/const-generics/mistyped_const_in_pat.rs
index 62d5438b4e4..6f1dd52872f 100644
--- a/tests/crashes/125799.rs
+++ b/tests/ui/const-generics/mistyped_const_in_pat.rs
@@ -1,4 +1,5 @@
-//@ known-bug: rust-lang/rust#125799
+//! Used to ICE rust-lang/rust#125799 due to `isize` != `()`
+//! not being detected early due to the conflicting impls.
 //@ only-x86_64
 
 trait Trait<T> {
@@ -10,6 +11,7 @@ impl<T> Trait<T> for Vec<T> {
 }
 
 impl Trait<u8> for Vec<u8> {}
+//~^ ERROR: conflicting implementations
 
 const BAR: <Vec<u8> as Trait<u8>>::Assoc = 3;
 
diff --git a/tests/ui/const-generics/mistyped_const_in_pat.stderr b/tests/ui/const-generics/mistyped_const_in_pat.stderr
new file mode 100644
index 00000000000..de7516fa37f
--- /dev/null
+++ b/tests/ui/const-generics/mistyped_const_in_pat.stderr
@@ -0,0 +1,12 @@
+error[E0119]: conflicting implementations of trait `Trait<u8>` for type `Vec<u8>`
+  --> $DIR/mistyped_const_in_pat.rs:13:1
+   |
+LL | impl<T> Trait<T> for Vec<T> {
+   | --------------------------- first implementation here
+...
+LL | impl Trait<u8> for Vec<u8> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Vec<u8>`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0119`.
diff --git a/tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr b/tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
index 5bef6f3c795..4809f7d37dd 100644
--- a/tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
+++ b/tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
@@ -4,11 +4,11 @@ error[E0284]: type annotations needed
 LL |     generics_of_parent_impl_trait::foo([()]);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of const parameter `N` declared on the function `foo`
    |
-note: required by a bound in `foo`
-  --> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:48
+note: required by a const generic parameter in `foo`
+  --> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:12
    |
 LL | pub fn foo<const N: usize>(foo: impl Into<[(); N + 1]>) {
-   |                                                ^^^^^ required by this bound in `foo`
+   |            ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/type_mismatch.stderr b/tests/ui/const-generics/type_mismatch.stderr
index 07476ae76c6..026999827c0 100644
--- a/tests/ui/const-generics/type_mismatch.stderr
+++ b/tests/ui/const-generics/type_mismatch.stderr
@@ -4,11 +4,11 @@ error: the constant `N` is not of type `u8`
 LL |     bar::<N>()
    |           ^ expected `u8`, found `usize`
    |
-note: required by a bound in `bar`
+note: required by a const generic parameter in `bar`
   --> $DIR/type_mismatch.rs:6:8
    |
 LL | fn bar<const N: u8>() -> [u8; N] {}
-   |        ^^^^^^^^^^^ required by this bound in `bar`
+   |        ^^^^^^^^^^^ required by this const generic parameter in `bar`
 
 error[E0308]: mismatched types
   --> $DIR/type_mismatch.rs:6:26
diff --git a/tests/ui/const-generics/unify_with_nested_expr.stderr b/tests/ui/const-generics/unify_with_nested_expr.stderr
index e050254a3e9..b1aecdb3cb5 100644
--- a/tests/ui/const-generics/unify_with_nested_expr.stderr
+++ b/tests/ui/const-generics/unify_with_nested_expr.stderr
@@ -4,14 +4,11 @@ error[E0284]: type annotations needed
 LL |     bar();
    |     ^^^ cannot infer the value of the const parameter `N` declared on the function `bar`
    |
-note: required by a bound in `bar`
-  --> $DIR/unify_with_nested_expr.rs:14:10
+note: required by a const generic parameter in `bar`
+  --> $DIR/unify_with_nested_expr.rs:12:8
    |
 LL | fn bar<const N: usize>()
-   |    --- required by a bound in this function
-LL | where
-LL |     [(); N + 1]:,
-   |          ^^^^^ required by this bound in `bar`
+   |        ^^^^^^^^^^^^^^ required by this const generic parameter in `bar`
 help: consider specifying the generic argument
    |
 LL |     bar::<N>();
diff --git a/tests/ui/impl-trait/upvar_captures.rs b/tests/ui/impl-trait/upvar_captures.rs
new file mode 100644
index 00000000000..61e3cda66f5
--- /dev/null
+++ b/tests/ui/impl-trait/upvar_captures.rs
@@ -0,0 +1,16 @@
+//! This test used to ICE: rust-lang/rust#123255
+//! Because the errors on `C` were ignored when trying
+//! to compute the MIR of the closure, which thus ended
+//! up with broken upvars.
+//@ edition:2021
+#![crate_type = "lib"]
+
+pub fn a() {}
+
+mod handlers {
+    pub struct C(&()); //~ ERROR missing lifetime specifier
+    pub fn c() -> impl Fn() -> C {
+        let a1 = ();
+        || C((crate::a(), a1).into())
+    }
+}
diff --git a/tests/ui/impl-trait/upvar_captures.stderr b/tests/ui/impl-trait/upvar_captures.stderr
new file mode 100644
index 00000000000..b87a16606cc
--- /dev/null
+++ b/tests/ui/impl-trait/upvar_captures.stderr
@@ -0,0 +1,14 @@
+error[E0106]: missing lifetime specifier
+  --> $DIR/upvar_captures.rs:11:18
+   |
+LL |     pub struct C(&());
+   |                  ^ expected named lifetime parameter
+   |
+help: consider introducing a named lifetime parameter
+   |
+LL |     pub struct C<'a>(&'a ());
+   |                 ++++  ++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0106`.
diff --git a/tests/ui/inference/issue-83606.stderr b/tests/ui/inference/issue-83606.stderr
index 8e6ff6d568d..69d1d71ef3c 100644
--- a/tests/ui/inference/issue-83606.stderr
+++ b/tests/ui/inference/issue-83606.stderr
@@ -1,9 +1,14 @@
-error[E0282]: type annotations needed for `[usize; _]`
+error[E0284]: type annotations needed for `[usize; _]`
   --> $DIR/issue-83606.rs:8:9
    |
 LL |     let _ = foo("foo");
-   |         ^
+   |         ^   ---------- type must be known at this point
    |
+note: required by a const generic parameter in `foo`
+  --> $DIR/issue-83606.rs:3:8
+   |
+LL | fn foo<const N: usize>(_: impl std::fmt::Display) -> [usize; N] {
+   |        ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
 help: consider giving this pattern a type, where the value of const parameter `N` is specified
    |
 LL |     let _: [usize; N] = foo("foo");
@@ -11,4 +16,4 @@ LL |     let _: [usize; N] = foo("foo");
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/issues/issue-98299.rs b/tests/ui/issues/issue-98299.rs
index 63c058f91fc..ba63d963475 100644
--- a/tests/ui/issues/issue-98299.rs
+++ b/tests/ui/issues/issue-98299.rs
@@ -3,6 +3,8 @@ use std::convert::TryFrom;
 pub fn test_usage(p: ()) {
     SmallCString::try_from(p).map(|cstr| cstr);
     //~^ ERROR: type annotations needed
+    //~| ERROR: type annotations needed
+    //~| ERROR: type annotations needed
 }
 
 pub struct SmallCString<const N: usize> {}
diff --git a/tests/ui/issues/issue-98299.stderr b/tests/ui/issues/issue-98299.stderr
index becf16d1db9..b645267e3b9 100644
--- a/tests/ui/issues/issue-98299.stderr
+++ b/tests/ui/issues/issue-98299.stderr
@@ -1,14 +1,61 @@
-error[E0282]: type annotations needed for `SmallCString<_>`
+error[E0284]: type annotations needed for `SmallCString<_>`
   --> $DIR/issue-98299.rs:4:36
    |
 LL |     SmallCString::try_from(p).map(|cstr| cstr);
-   |                                    ^^^^
+   |     ------------                   ^^^^
+   |     |
+   |     type must be known at this point
    |
+note: required by a const generic parameter in `SmallCString`
+  --> $DIR/issue-98299.rs:10:25
+   |
+LL | pub struct SmallCString<const N: usize> {}
+   |                         ^^^^^^^^^^^^^^ required by this const generic parameter in `SmallCString`
+help: consider giving this closure parameter an explicit type, where the value of const parameter `N` is specified
+   |
+LL |     SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr);
+   |                                        +++++++++++++++++
+
+error[E0284]: type annotations needed for `SmallCString<_>`
+  --> $DIR/issue-98299.rs:4:36
+   |
+LL |     SmallCString::try_from(p).map(|cstr| cstr);
+   |     ------------                   ^^^^
+   |     |
+   |     type must be known at this point
+   |
+note: required for `SmallCString<_>` to implement `TryFrom<()>`
+  --> $DIR/issue-98299.rs:12:22
+   |
+LL | impl<const N: usize> TryFrom<()> for SmallCString<N> {
+   |      --------------  ^^^^^^^^^^^     ^^^^^^^^^^^^^^^
+   |      |
+   |      unsatisfied trait bound introduced here
+help: consider giving this closure parameter an explicit type, where the value of const parameter `N` is specified
+   |
+LL |     SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr);
+   |                                        +++++++++++++++++
+
+error[E0284]: type annotations needed for `SmallCString<_>`
+  --> $DIR/issue-98299.rs:4:36
+   |
+LL |     SmallCString::try_from(p).map(|cstr| cstr);
+   |     -------------------------      ^^^^
+   |     |
+   |     type must be known at this point
+   |
+note: required for `SmallCString<_>` to implement `TryFrom<()>`
+  --> $DIR/issue-98299.rs:12:22
+   |
+LL | impl<const N: usize> TryFrom<()> for SmallCString<N> {
+   |      --------------  ^^^^^^^^^^^     ^^^^^^^^^^^^^^^
+   |      |
+   |      unsatisfied trait bound introduced here
 help: consider giving this closure parameter an explicit type, where the value of const parameter `N` is specified
    |
 LL |     SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr);
    |                                        +++++++++++++++++
 
-error: aborting due to 1 previous error
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr
index e45c1a1f46f..86dfc521fea 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr
@@ -37,6 +37,19 @@ error[E0207]: the const parameter `host` is not constrained by the impl trait, s
    = note: expressions using a const parameter must map each value to a distinct output value
    = note: proving the result of expressions other than the parameter are unique is not supported
 
+error[E0284]: type annotations needed
+  --> $DIR/derive-const-use.rs:18:35
+   |
+LL | const _: () = assert!(S((), A) == S::default());
+   |                                   ^^^^^^^^^^^^ cannot infer the value of the constant `_`
+   |
+note: required for `S` to implement `Default`
+  --> $DIR/derive-const-use.rs:15:16
+   |
+LL | #[derive_const(Default, PartialEq)]
+   |                ^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
+   = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error[E0308]: mismatched types
   --> $DIR/derive-const-use.rs:16:14
    |
@@ -49,7 +62,24 @@ LL | pub struct S((), A);
               found constant `true`
    = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 6 previous errors
+error[E0284]: type annotations needed
+  --> $DIR/derive-const-use.rs:16:18
+   |
+LL | #[derive_const(Default, PartialEq)]
+   |                ------- in this derive macro expansion
+LL | pub struct S((), A);
+   |                  ^ cannot infer the value of the constant `_`
+   |
+note: required for `A` to implement `Default`
+  --> $DIR/derive-const-use.rs:7:12
+   |
+LL | impl const Default for A {
+   |      ----- ^^^^^^^     ^
+   |      |
+   |      unsatisfied trait bound introduced here
+   = note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 8 previous errors
 
-Some errors have detailed explanations: E0207, E0308, E0635.
+Some errors have detailed explanations: E0207, E0284, E0308, E0635.
 For more information about an error, try `rustc --explain E0207`.
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/trait-default-body-stability.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/trait-default-body-stability.stderr
index 62c4bc3b7ae..b58af6bb9d0 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/trait-default-body-stability.stderr
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/trait-default-body-stability.stderr
@@ -34,6 +34,94 @@ LL | impl const FromResidual for T {
    = note: expressions using a const parameter must map each value to a distinct output value
    = note: proving the result of expressions other than the parameter are unique is not supported
 
-error: aborting due to 4 previous errors
+error[E0284]: type annotations needed
+  --> $DIR/trait-default-body-stability.rs:33:6
+   |
+LL | impl const FromResidual for T {
+   |      ^^^^^ cannot infer the value of the constant `_`
+   |
+note: required for `T` to implement `Try`
+  --> $DIR/trait-default-body-stability.rs:18:12
+   |
+LL | impl const Try for T {
+   |      ----- ^^^     ^
+   |      |
+   |      unsatisfied trait bound introduced here
+
+error[E0284]: type annotations needed
+  --> $DIR/trait-default-body-stability.rs:44:9
+   |
+LL |         T?
+   |         ^^ cannot infer the value of the constant `_`
+   |
+note: required for `T` to implement `Try`
+  --> $DIR/trait-default-body-stability.rs:18:12
+   |
+LL | impl const Try for T {
+   |      ----- ^^^     ^
+   |      |
+   |      unsatisfied trait bound introduced here
+
+error[E0284]: type annotations needed
+  --> $DIR/trait-default-body-stability.rs:44:9
+   |
+LL |         T?
+   |         ^^ cannot infer the value of the constant `_`
+   |
+note: required for `T` to implement `FromResidual<T>`
+  --> $DIR/trait-default-body-stability.rs:33:12
+   |
+LL | impl const FromResidual for T {
+   |      ----- ^^^^^^^^^^^^     ^
+   |      |
+   |      unsatisfied trait bound introduced here
+
+error[E0284]: type annotations needed
+  --> $DIR/trait-default-body-stability.rs:44:9
+   |
+LL |         T?
+   |         ^^ cannot infer the value of the constant `_`
+   |
+note: required for `T` to implement `Try`
+  --> $DIR/trait-default-body-stability.rs:18:12
+   |
+LL | impl const Try for T {
+   |      ----- ^^^     ^
+   |      |
+   |      unsatisfied trait bound introduced here
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0284]: type annotations needed
+  --> $DIR/trait-default-body-stability.rs:44:9
+   |
+LL |         T?
+   |         ^^ cannot infer the value of the constant `_`
+   |
+note: required for `T` to implement `FromResidual<T>`
+  --> $DIR/trait-default-body-stability.rs:33:12
+   |
+LL | impl const FromResidual for T {
+   |      ----- ^^^^^^^^^^^^     ^
+   |      |
+   |      unsatisfied trait bound introduced here
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0284]: type annotations needed
+  --> $DIR/trait-default-body-stability.rs:44:9
+   |
+LL |         T?
+   |         ^^ cannot infer the value of the constant `_`
+   |
+note: required for `T` to implement `Try`
+  --> $DIR/trait-default-body-stability.rs:18:12
+   |
+LL | impl const Try for T {
+   |      ----- ^^^     ^
+   |      |
+   |      unsatisfied trait bound introduced here
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 10 previous errors
 
-For more information about this error, try `rustc --explain E0207`.
+Some errors have detailed explanations: E0207, E0284.
+For more information about an error, try `rustc --explain E0207`.
diff --git a/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs b/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs
index 196da30b864..d0bf5078165 100644
--- a/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs
+++ b/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs
@@ -4,4 +4,5 @@ fn main() {
 //~| ERROR cannot find type `T` in this scope
 //~| ERROR const and type arguments are not allowed on builtin type `str`
 //~| ERROR expected unit struct, unit variant or constant, found associated function `str<
+//~| ERROR type annotations needed
 }
diff --git a/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr b/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr
index 99f8dbd9a6c..fc431eb1412 100644
--- a/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr
+++ b/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr
@@ -32,7 +32,18 @@ error[E0533]: expected unit struct, unit variant or constant, found associated f
 LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a unit struct, unit variant or constant
 
-error: aborting due to 4 previous errors
+error[E0282]: type annotations needed
+  --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:31
+   |
+LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
+   |                               ^^^^^^^^^^^^^^^^^^
+   |
+help: consider giving this pattern a type
+   |
+LL |     let str::<{fn str() { let str::T>>::as_bytes: /* Type */; }}, T>::as_bytes;
+   |                                                 ++++++++++++
+
+error: aborting due to 5 previous errors
 
-Some errors have detailed explanations: E0109, E0412, E0533.
+Some errors have detailed explanations: E0109, E0282, E0412, E0533.
 For more information about an error, try `rustc --explain E0109`.
diff --git a/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr b/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr
index b4c14c2294e..71d4277275f 100644
--- a/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr
+++ b/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr
@@ -14,11 +14,11 @@ LL | impl<const C: usize> Wrapper<C> {}
    |
    = help: consider constraining the associated type `<i32 as Trait>::Type` to `usize`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
-note: required by a bound in `Wrapper`
+note: required by a const generic parameter in `Wrapper`
   --> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:12:16
    |
 LL | struct Wrapper<const C: <i32 as Trait>::Type> {}
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Wrapper`
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Wrapper`
 
 error[E0308]: mismatched types
   --> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:15:30
diff --git a/tests/ui/transmutability/issue-101739-1.stderr b/tests/ui/transmutability/issue-101739-1.stderr
index 1df7c3e2f97..6f79bf7b424 100644
--- a/tests/ui/transmutability/issue-101739-1.stderr
+++ b/tests/ui/transmutability/issue-101739-1.stderr
@@ -10,7 +10,7 @@ error: the constant `ASSUME_ALIGNMENT` is not of type `Assume`
 LL |         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
    |
-note: required by a bound in `BikeshedIntrinsicFrom`
+note: required by a const generic parameter in `BikeshedIntrinsicFrom`
   --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
 
 error[E0308]: mismatched types
diff --git a/tests/crashes/123276.rs b/tests/ui/where-clauses/normalization-of-unknown-type.rs
index d2246f59583..c3ff7ed125a 100644
--- a/tests/crashes/123276.rs
+++ b/tests/ui/where-clauses/normalization-of-unknown-type.rs
@@ -1,4 +1,6 @@
-//@ known-bug: rust-lang/rust#123276
+//! This test used to ICE: rust-lang/rust#123276 because we did
+//! not taint when failing to find the `Foo` type and then tried
+//! to normalize it.
 //@ edition:2021
 
 async fn create_task() {
@@ -19,7 +21,9 @@ struct AndThen;
 
 impl Filter for AndThen
 where
-    Foo: Filter,
+    Foo: Filter, //~ ERROR: cannot find type `Foo`
 {
     type Future = ();
 }
+
+fn main() {}
diff --git a/tests/ui/where-clauses/normalization-of-unknown-type.stderr b/tests/ui/where-clauses/normalization-of-unknown-type.stderr
new file mode 100644
index 00000000000..11b83224352
--- /dev/null
+++ b/tests/ui/where-clauses/normalization-of-unknown-type.stderr
@@ -0,0 +1,9 @@
+error[E0412]: cannot find type `Foo` in this scope
+  --> $DIR/normalization-of-unknown-type.rs:24:5
+   |
+LL |     Foo: Filter,
+   |     ^^^ not found in this scope
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0412`.