Rollup merge of #129246 - BoxyUwU:feature_gate_const_arg_path, r=cjgillot

Retroactively feature gate `ConstArgKind::Path`

This puts the lowering introduced by #125915 under a feature gate until we fix the regressions introduced by it. Alternative to whole sale reverting the PR since it didn't seem like a very clean revert and I think this is generally a step in the right direction and don't want to get stuck landing and reverting the PR over and over :)

cc #129137 ``@camelid,`` tests taken from there. beta is branching soon so I think it makes sense to not try and rush that fix through since it wont have much time to bake and if it has issues we can't simply revert it on beta.

Fixes #128016

41 files changed, 425 insertions, 206 deletions

diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 51cbe808a3a..e077c544965 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -220,7 +220,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             let parent_def_id = self.current_def_id_parent;
                             let node_id = self.next_node_id();
                             // HACK(min_generic_const_args): see lower_anon_const
-                            if !expr.is_potential_trivial_const_arg() {
+                            if !self.tcx.features().const_arg_path
+                                || !expr.is_potential_trivial_const_arg()
+                            {
                                 self.create_def(
                                     parent_def_id,
                                     node_id,
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index b5d8a547a8f..bb86e5c9325 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -387,7 +387,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let node_id = self.next_node_id();
 
                 // HACK(min_generic_const_args): see lower_anon_const
-                if !arg.is_potential_trivial_const_arg() {
+                if !self.tcx.features().const_arg_path || !arg.is_potential_trivial_const_arg() {
                     // Add a definition for the in-band const def.
                     self.create_def(parent_def_id, node_id, kw::Empty, DefKind::AnonConst, f.span);
                 }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 81d17a9dec2..4b8c47ac4b4 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2358,7 +2358,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         span: Span,
     ) -> &'hir hir::ConstArg<'hir> {
         let ct_kind = match res {
-            Res::Def(DefKind::ConstParam, _) => {
+            Res::Def(DefKind::ConstParam, _) if self.tcx.features().const_arg_path => {
                 let qpath = self.lower_qpath(
                     ty_id,
                     &None,
@@ -2433,7 +2433,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             self.resolver.get_partial_res(expr.id).and_then(|partial_res| partial_res.full_res());
         debug!("res={:?}", maybe_res);
         // FIXME(min_generic_const_args): for now we only lower params to ConstArgKind::Path
-        if let Some(res) = maybe_res
+        if self.tcx.features().const_arg_path
+            && let Some(res) = maybe_res
             && let Res::Def(DefKind::ConstParam, _) = res
             && let ExprKind::Path(qself, path) = &expr.kind
         {
@@ -2464,7 +2465,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     /// See [`hir::ConstArg`] for when to use this function vs
     /// [`Self::lower_anon_const_to_const_arg`].
     fn lower_anon_const_to_anon_const(&mut self, c: &AnonConst) -> &'hir hir::AnonConst {
-        if c.value.is_potential_trivial_const_arg() {
+        if self.tcx.features().const_arg_path && c.value.is_potential_trivial_const_arg() {
             // HACK(min_generic_const_args): see DefCollector::visit_anon_const
             // Over there, we guess if this is a bare param and only create a def if
             // we think it's not. However we may can guess wrong (see there for example)
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 3a143c52a8c..4524458023d 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -193,6 +193,8 @@ declare_features! (
     (unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None),
     /// Allows identifying the `compiler_builtins` crate.
     (internal, compiler_builtins, "1.13.0", None),
+    /// Gating for a new desugaring of const arguments of usages of const parameters
+    (internal, const_arg_path, "1.81.0", None),
     /// Allows writing custom MIR
     (internal, custom_mir, "1.65.0", None),
     /// Outputs useful `assert!` messages
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index e373292741b..362ff8e988d 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -240,7 +240,7 @@ impl<'tcx> Const<'tcx> {
 
         let ty = tcx.type_of(def).no_bound_vars().expect("const parameter types cannot be generic");
 
-        match Self::try_from_lit(tcx, ty, expr) {
+        match Self::try_from_lit_or_param(tcx, ty, expr) {
             Some(v) => v,
             None => ty::Const::new_unevaluated(
                 tcx,
@@ -281,7 +281,11 @@ impl<'tcx> Const<'tcx> {
     }
 
     #[instrument(skip(tcx), level = "debug")]
-    fn try_from_lit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'tcx>) -> Option<Self> {
+    fn try_from_lit_or_param(
+        tcx: TyCtxt<'tcx>,
+        ty: Ty<'tcx>,
+        expr: &'tcx hir::Expr<'tcx>,
+    ) -> Option<Self> {
         // Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
         // currently have to be wrapped in curly brackets, so it's necessary to special-case.
         let expr = match &expr.kind {
@@ -291,6 +295,22 @@ impl<'tcx> Const<'tcx> {
             _ => expr,
         };
 
+        if let hir::ExprKind::Path(
+            qpath @ hir::QPath::Resolved(
+                _,
+                &hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
+            ),
+        ) = expr.kind
+        {
+            if tcx.features().const_arg_path {
+                span_bug!(
+                    expr.span,
+                    "try_from_lit: received const param which shouldn't be possible"
+                );
+            }
+            return Some(Const::from_param(tcx, qpath, expr.hir_id));
+        };
+
         let lit_input = match expr.kind {
             hir::ExprKind::Lit(lit) => Some(LitToConstInput { lit: &lit.node, ty, neg: false }),
             hir::ExprKind::Unary(hir::UnOp::Neg, expr) => match expr.kind {
@@ -318,14 +338,6 @@ impl<'tcx> Const<'tcx> {
             }
         }
 
-        if let hir::ExprKind::Path(hir::QPath::Resolved(
-            _,
-            &hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
-        )) = expr.kind
-        {
-            span_bug!(expr.span, "try_from_lit: received const param which shouldn't be possible")
-        }
-
         None
     }
 
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index ed23870dfdf..3595db78e93 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -314,13 +314,15 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
     }
 
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
-        // HACK(min_generic_const_args): don't create defs for anon consts if we think they will
-        // later be turned into ConstArgKind::Path's. because this is before resolve is done, we
-        // may accidentally identify a construction of a unit struct as a param and not create a
-        // def. we'll then create a def later in ast lowering in this case. the parent of nested
-        // items will be messed up, but that's ok because there can't be any if we're just looking
-        // for bare idents.
-        if constant.value.is_potential_trivial_const_arg() {
+        if self.resolver.tcx.features().const_arg_path
+            && constant.value.is_potential_trivial_const_arg()
+        {
+            // HACK(min_generic_const_args): don't create defs for anon consts if we think they will
+            // later be turned into ConstArgKind::Path's. because this is before resolve is done, we
+            // may accidentally identify a construction of a unit struct as a param and not create a
+            // def. we'll then create a def later in ast lowering in this case. the parent of nested
+            // items will be messed up, but that's ok because there can't be any if we're just looking
+            // for bare idents.
             visit::walk_anon_const(self, constant)
         } else {
             let def =
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index a2e94492f8c..942026cd7bf 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -595,6 +595,7 @@ symbols! {
         conservative_impl_trait,
         console,
         const_allocate,
+        const_arg_path,
         const_async_blocks,
         const_closures,
         const_compare_raw_pointers,
diff --git a/tests/crashes/127972.rs b/tests/crashes/127972.rs
index d0764f875db..797dd7e6020 100644
--- a/tests/crashes/127972.rs
+++ b/tests/crashes/127972.rs
@@ -1,5 +1,5 @@
 //@ known-bug: #127962
-#![feature(generic_const_exprs)]
+#![feature(generic_const_exprs, const_arg_path)]
 
 fn zero_init<const usize: usize>() -> Substs1<{ (N) }> {
     Substs1([0; { (usize) }])
diff --git a/tests/crashes/128016.rs b/tests/crashes/128016.rs
deleted file mode 100644
index d23721ae14e..00000000000
--- a/tests/crashes/128016.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ known-bug: #128016
-macro_rules! len {
-    () => {
-        target
-    };
-}
-
-fn main() {
-    let val: [str; len!()] = [];
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_instance.rs b/tests/ui-fulldeps/stable-mir/check_instance.rs
index 5e3f2557566..5449c09d35a 100644
--- a/tests/ui-fulldeps/stable-mir/check_instance.rs
+++ b/tests/ui-fulldeps/stable-mir/check_instance.rs
@@ -17,12 +17,14 @@ extern crate rustc_driver;
 extern crate rustc_interface;
 extern crate stable_mir;
 
-use mir::{mono::Instance, TerminatorKind::*};
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use mir::mono::Instance;
+use mir::TerminatorKind::*;
 use rustc_smir::rustc_internal;
 use stable_mir::ty::{RigidTy, TyKind};
 use stable_mir::*;
-use std::io::Write;
-use std::ops::ControlFlow;
 
 const CRATE_NAME: &str = "input";
 
@@ -33,7 +35,7 @@ fn test_stable_mir() -> ControlFlow<()> {
     // Get all items and split generic vs monomorphic items.
     let (generic, mono): (Vec<_>, Vec<_>) =
         items.into_iter().partition(|item| item.requires_monomorphization());
-    assert_eq!(mono.len(), 3, "Expected 3 mono functions");
+    assert_eq!(mono.len(), 4, "Expected 3 mono functions");
     assert_eq!(generic.len(), 2, "Expected 2 generic functions");
 
     // For all monomorphic items, get the correspondent instances.
diff --git a/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs b/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs
index e07fa78463c..cdfeb9c434e 100644
--- a/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs
+++ b/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs
@@ -5,7 +5,9 @@
 #![feature(with_negative_coherence)]
 trait Trait {}
 impl<const N: u8> Trait for [(); N] {}
+//~^ ERROR: mismatched types
 impl<const N: i8> Trait for [(); N] {}
 //~^ ERROR: conflicting implementations of trait `Trait`
+//~| ERROR: mismatched types
 
 fn main() {}
diff --git a/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr b/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr
index 2087be8e711..d65450845bc 100644
--- a/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr
+++ b/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr
@@ -1,11 +1,25 @@
 error[E0119]: conflicting implementations of trait `Trait` for type `[(); _]`
-  --> $DIR/generic_const_type_mismatch.rs:8:1
+  --> $DIR/generic_const_type_mismatch.rs:9:1
    |
 LL | impl<const N: u8> Trait for [(); N] {}
    | ----------------------------------- first implementation here
+LL |
 LL | impl<const N: i8> Trait for [(); N] {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[(); _]`
 
-error: aborting due to 1 previous error
+error[E0308]: mismatched types
+  --> $DIR/generic_const_type_mismatch.rs:7:34
+   |
+LL | impl<const N: u8> Trait for [(); N] {}
+   |                                  ^ expected `usize`, found `u8`
+
+error[E0308]: mismatched types
+  --> $DIR/generic_const_type_mismatch.rs:9:34
+   |
+LL | impl<const N: i8> Trait for [(); N] {}
+   |                                  ^ expected `usize`, found `i8`
+
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0119`.
+Some errors have detailed explanations: E0119, E0308.
+For more information about an error, try `rustc --explain E0119`.
diff --git a/tests/ui/const-generics/bad-subst-const-kind.rs b/tests/ui/const-generics/bad-subst-const-kind.rs
index cc2ff9b8dea..c4e74596e9f 100644
--- a/tests/ui/const-generics/bad-subst-const-kind.rs
+++ b/tests/ui/const-generics/bad-subst-const-kind.rs
@@ -7,6 +7,7 @@ trait Q {
 
 impl<const N: u64> Q for [u8; N] {
     //~^ ERROR: the constant `N` is not of type `usize`
+    //~| ERROR: mismatched types
     const ASSOC: usize = 1;
 }
 
diff --git a/tests/ui/const-generics/bad-subst-const-kind.stderr b/tests/ui/const-generics/bad-subst-const-kind.stderr
index 5c8d9c90363..21ec8f0768c 100644
--- a/tests/ui/const-generics/bad-subst-const-kind.stderr
+++ b/tests/ui/const-generics/bad-subst-const-kind.stderr
@@ -5,7 +5,7 @@ LL | impl<const N: u64> Q for [u8; N] {
    |                          ^^^^^^^ expected `usize`, found `u64`
 
 error: the constant `13` is not of type `u64`
-  --> $DIR/bad-subst-const-kind.rs:13:24
+  --> $DIR/bad-subst-const-kind.rs:14:24
    |
 LL | pub fn test() -> [u8; <[u8; 13] as Q>::ASSOC] {
    |                        ^^^^^^^^ expected `u64`, found `usize`
@@ -18,5 +18,12 @@ LL | impl<const N: u64> Q for [u8; N] {
    |      |
    |      unsatisfied trait bound introduced here
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/bad-subst-const-kind.rs:8:31
+   |
+LL | impl<const N: u64> Q for [u8; N] {
+   |                               ^ expected `usize`, found `u64`
+
+error: aborting due to 3 previous errors
 
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro-nested.rs b/tests/ui/const-generics/early/trivial-const-arg-macro-nested.rs
new file mode 100644
index 00000000000..f9730cf8566
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro-nested.rs
@@ -0,0 +1,21 @@
+//@ check-pass
+
+// This is a regression test for #128016.
+
+macro_rules! len_inner {
+    () => {
+        BAR
+    };
+}
+
+macro_rules! len {
+    () => {
+        len_inner!()
+    };
+}
+
+const BAR: usize = 0;
+
+fn main() {
+    let val: [bool; len!()] = [];
+}
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro-param.rs b/tests/ui/const-generics/early/trivial-const-arg-macro-param.rs
new file mode 100644
index 00000000000..f123e55c028
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro-param.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+
+macro_rules! len {
+    ($x:ident) => {
+        $x
+    };
+}
+
+fn bar<const N: usize>() {
+    let val: [bool; len!(N)] = [true; N];
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.rs b/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.rs
new file mode 100644
index 00000000000..f218caac0cf
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.rs
@@ -0,0 +1,13 @@
+// This is a regression test for #128016.
+
+macro_rules! len {
+    () => {
+        target
+        //~^ ERROR cannot find value `target`
+    };
+}
+
+fn main() {
+    let val: [str; len!()] = [];
+    //~^ ERROR the size for values
+}
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.stderr b/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.stderr
new file mode 100644
index 00000000000..ab289e5a6b7
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.stderr
@@ -0,0 +1,24 @@
+error[E0425]: cannot find value `target` in this scope
+  --> $DIR/trivial-const-arg-macro-res-error.rs:5:9
+   |
+LL |         target
+   |         ^^^^^^ not found in this scope
+...
+LL |     let val: [str; len!()] = [];
+   |                    ------ in this macro invocation
+   |
+   = note: this error originates in the macro `len` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/trivial-const-arg-macro-res-error.rs:11:14
+   |
+LL |     let val: [str; len!()] = [];
+   |              ^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `str`
+   = note: slice and array elements must have `Sized` type
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0277, E0425.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro.rs b/tests/ui/const-generics/early/trivial-const-arg-macro.rs
new file mode 100644
index 00000000000..a19d9abfdcb
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro.rs
@@ -0,0 +1,15 @@
+//@ check-pass
+
+// This is a regression test for #128016.
+
+macro_rules! len {
+    () => {
+        BAR
+    };
+}
+
+const BAR: usize = 0;
+
+fn main() {
+    let val: [bool; len!()] = [];
+}
diff --git a/tests/ui/const-generics/generic_const_exprs/type_mismatch.rs b/tests/ui/const-generics/generic_const_exprs/type_mismatch.rs
index 8e5e23b2337..a45deabbb0f 100644
--- a/tests/ui/const-generics/generic_const_exprs/type_mismatch.rs
+++ b/tests/ui/const-generics/generic_const_exprs/type_mismatch.rs
@@ -8,6 +8,7 @@ trait Q {
 impl<const N: u64> Q for [u8; N] {}
 //~^ ERROR not all trait items implemented
 //~| ERROR the constant `N` is not of type `usize`
+//~| ERROR mismatched types
 
 pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
 //~^ ERROR the constant `13` is not of type `u64`
diff --git a/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr b/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
index e03580ec007..68870a8d38d 100644
--- a/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
@@ -14,7 +14,7 @@ LL | impl<const N: u64> Q for [u8; N] {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `ASSOC` in implementation
 
 error: the constant `13` is not of type `u64`
-  --> $DIR/type_mismatch.rs:12:26
+  --> $DIR/type_mismatch.rs:13:26
    |
 LL | pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
    |                          ^^^^^^^^ expected `u64`, found `usize`
@@ -28,14 +28,20 @@ LL | impl<const N: u64> Q for [u8; N] {}
    |      unsatisfied trait bound introduced here
 
 error[E0308]: mismatched types
-  --> $DIR/type_mismatch.rs:12:20
+  --> $DIR/type_mismatch.rs:13:20
    |
 LL | pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
    |        ------      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `[u8; <[u8; 13] as Q>::ASSOC]`, found `()`
    |        |
    |        implicitly returns `()` as its body has no tail or `return` expression
 
-error: aborting due to 4 previous errors
+error[E0308]: mismatched types
+  --> $DIR/type_mismatch.rs:8:31
+   |
+LL | impl<const N: u64> Q for [u8; N] {}
+   |                               ^ expected `usize`, found `u64`
+
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0046, E0308.
 For more information about an error, try `rustc --explain E0046`.
diff --git a/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs b/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs
index 8b7ee577569..05a3487ffca 100644
--- a/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs
+++ b/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs
@@ -14,8 +14,8 @@ mod v20 {
     //~^ ERROR cannot find value `v8` in this scope
     //~| ERROR cannot find function `v6` in this scope
     pub struct v17<const v10: usize, const v7: v11> {
-    //~^ WARN type `v17` should have an upper camel case name
-    //~| ERROR `[[usize; v4]; v4]` is forbidden as the type of a const generic parameter
+        //~^ WARN type `v17` should have an upper camel case name
+        //~| ERROR `[[usize; v4]; v4]` is forbidden as the type of a const generic parameter
         _p: (),
     }
 
@@ -25,10 +25,10 @@ mod v20 {
     }
 
     impl<const v10: usize> v17<v10, v2> {
-    //~^ ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
-    //~| ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
+        //~^ ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
+        //~| ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
         pub const fn v21() -> v18 {
-        //~^ ERROR cannot find type `v18` in this scope
+            //~^ ERROR cannot find type `v18` in this scope
             v18 { _p: () }
             //~^ ERROR cannot find struct, variant or union type `v18` in this scope
         }
diff --git a/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr b/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr
index 15d3c472585..39f022fbee9 100644
--- a/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr
@@ -72,13 +72,13 @@ help: add `#![feature(adt_const_params)]` to the crate attributes to enable more
 LL + #![feature(adt_const_params)]
    |
 
-error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
+error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
   --> $DIR/unevaluated-const-ice-119731.rs:27:37
    |
 LL |     impl<const v10: usize> v17<v10, v2> {
    |                                     ^^
 
-error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
+error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
   --> $DIR/unevaluated-const-ice-119731.rs:27:37
    |
 LL |     impl<const v10: usize> v17<v10, v2> {
diff --git a/tests/ui/const-generics/transmute-fail.rs b/tests/ui/const-generics/transmute-fail.rs
index 59b77c678e8..a9b297ffb62 100644
--- a/tests/ui/const-generics/transmute-fail.rs
+++ b/tests/ui/const-generics/transmute-fail.rs
@@ -2,108 +2,108 @@
 #![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
-fn foo<const W: usize, const H: usize>(v: [[u32;H+1]; W]) -> [[u32; W+1]; H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR cannot transmute
-  }
+fn foo<const W: usize, const H: usize>(v: [[u32; H + 1]; W]) -> [[u32; W + 1]; H] {
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR cannot transmute
+    }
 }
 
 fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
-  //~^ ERROR the constant `W` is not of type `usize`
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR the constant `W` is not of type `usize`
-  }
+    //~^ ERROR: the constant `W` is not of type `usize`
+    //~| ERROR: mismatched types
+    //~| ERROR: mismatched types
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: the constant `W` is not of type `usize`
+    }
 }
 
 fn baz<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [u32; W * H * H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR cannot transmute
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR cannot transmute
+    }
 }
 
 fn overflow(v: [[[u32; 8888888]; 9999999]; 777777777]) -> [[[u32; 9999999]; 777777777]; 8888888] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR cannot transmute
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR cannot transmute
+    }
 }
 
-fn transpose<const W: usize, const H: usize>(v: [[u32;H]; W]) -> [[u32; W]; H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+fn transpose<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn ident<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [[u32; H]; W] {
-  unsafe {
-    std::mem::transmute(v)
-  }
+    unsafe { std::mem::transmute(v) }
 }
 
 fn flatten<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [u32; W * H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
-fn coagulate<const W: usize, const H: usize>(v: [u32; H*W]) -> [[u32; W];H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+fn coagulate<const W: usize, const H: usize>(v: [u32; H * W]) -> [[u32; W]; H] {
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn flatten_3d<const W: usize, const H: usize, const D: usize>(
-  v: [[[u32; D]; H]; W]
+    v: [[[u32; D]; H]; W],
 ) -> [u32; D * W * H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn flatten_somewhat<const W: usize, const H: usize, const D: usize>(
-  v: [[[u32; D]; H]; W]
+    v: [[[u32; D]; H]; W],
 ) -> [[u32; D * W]; H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn known_size<const L: usize>(v: [u16; L]) -> [u8; L * 2] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn condense_bytes<const L: usize>(v: [u8; L * 2]) -> [u16; L] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
-fn singleton_each<const L: usize>(v: [u8; L]) -> [[u8;1]; L] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+fn singleton_each<const L: usize>(v: [u8; L]) -> [[u8; 1]; L] {
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn transpose_with_const<const W: usize, const H: usize>(
-  v: [[u32; 2 * H]; W + W]
+    v: [[u32; 2 * H]; W + W],
 ) -> [[u32; W + W]; 2 * H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/const-generics/transmute-fail.stderr b/tests/ui/const-generics/transmute-fail.stderr
index b40fb23c331..124fbee8850 100644
--- a/tests/ui/const-generics/transmute-fail.stderr
+++ b/tests/ui/const-generics/transmute-fail.stderr
@@ -5,119 +5,132 @@ LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
    |                                          ^^^^^^^^^^^^^ expected `usize`, found `bool`
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:7:5
+  --> $DIR/transmute-fail.rs:7:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
-   = note: source type: `[[u32; H+1]; W]` (size can vary because of [u32; H+1])
-   = note: target type: `[[u32; W+1]; H]` (size can vary because of [u32; W+1])
+   = note: source type: `[[u32; H + 1]; W]` (size can vary because of [u32; H + 1])
+   = note: target type: `[[u32; W + 1]; H]` (size can vary because of [u32; W + 1])
 
 error: the constant `W` is not of type `usize`
-  --> $DIR/transmute-fail.rs:15:5
+  --> $DIR/transmute-fail.rs:17:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:22:5
+  --> $DIR/transmute-fail.rs:24:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
    = note: target type: `[u32; W * H * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:29:5
+  --> $DIR/transmute-fail.rs:31:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type `[[u32; 8888888]; 9999999]` are too big for the current architecture)
    = note: target type: `[[[u32; 9999999]; 777777777]; 8888888]` (values of the type `[[u32; 9999999]; 777777777]` are too big for the current architecture)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:36:5
+  --> $DIR/transmute-fail.rs:38:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
    = note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:49:5
+  --> $DIR/transmute-fail.rs:49:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
    = note: target type: `[u32; W * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:56:5
+  --> $DIR/transmute-fail.rs:56:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
-   = note: source type: `[u32; H*W]` (this type does not have a fixed size)
+   = note: source type: `[u32; H * W]` (this type does not have a fixed size)
    = note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:65:5
+  --> $DIR/transmute-fail.rs:65:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[[u32; D]; H]; W]` (size can vary because of [u32; D])
    = note: target type: `[u32; D * W * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:74:5
+  --> $DIR/transmute-fail.rs:74:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[[u32; D]; H]; W]` (size can vary because of [u32; D])
    = note: target type: `[[u32; D * W]; H]` (size can vary because of [u32; D * W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:81:5
+  --> $DIR/transmute-fail.rs:81:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[u16; L]` (this type does not have a fixed size)
    = note: target type: `[u8; L * 2]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:88:5
+  --> $DIR/transmute-fail.rs:88:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[u8; L * 2]` (this type does not have a fixed size)
    = note: target type: `[u16; L]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:95:5
+  --> $DIR/transmute-fail.rs:95:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[u8; L]` (this type does not have a fixed size)
    = note: target type: `[[u8; 1]; L]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:104:5
+  --> $DIR/transmute-fail.rs:104:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[u32; 2 * H]; W + W]` (size can vary because of [u32; 2 * H])
    = note: target type: `[[u32; W + W]; 2 * H]` (size can vary because of [u32; W + W])
 
-error: aborting due to 14 previous errors
+error[E0308]: mismatched types
+  --> $DIR/transmute-fail.rs:12:53
+   |
+LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
+   |                                                     ^ expected `usize`, found `bool`
+
+error[E0308]: mismatched types
+  --> $DIR/transmute-fail.rs:12:67
+   |
+LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
+   |                                                                   ^ expected `usize`, found `bool`
+
+error: aborting due to 16 previous errors
 
-For more information about this error, try `rustc --explain E0512`.
+Some errors have detailed explanations: E0308, E0512.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/type_mismatch.rs b/tests/ui/const-generics/type_mismatch.rs
index 8187c785cd1..9c7217cd83e 100644
--- a/tests/ui/const-generics/type_mismatch.rs
+++ b/tests/ui/const-generics/type_mismatch.rs
@@ -1,10 +1,12 @@
 fn foo<const N: usize>() -> [u8; N] {
     bar::<N>()
     //~^ ERROR the constant `N` is not of type `u8`
+    //~| ERROR: mismatched types
 }
 
 fn bar<const N: u8>() -> [u8; N] {}
 //~^ ERROR the constant `N` is not of type `usize`
+//~| ERROR: mismatched types
 //~| ERROR mismatched types
 
 fn main() {}
diff --git a/tests/ui/const-generics/type_mismatch.stderr b/tests/ui/const-generics/type_mismatch.stderr
index d1bb5c1242f..77e9f5e2b44 100644
--- a/tests/ui/const-generics/type_mismatch.stderr
+++ b/tests/ui/const-generics/type_mismatch.stderr
@@ -1,5 +1,5 @@
 error: the constant `N` is not of type `usize`
-  --> $DIR/type_mismatch.rs:6:26
+  --> $DIR/type_mismatch.rs:7:26
    |
 LL | fn bar<const N: u8>() -> [u8; N] {}
    |                          ^^^^^^^ expected `usize`, found `u8`
@@ -11,19 +11,31 @@ LL |     bar::<N>()
    |           ^ expected `u8`, found `usize`
    |
 note: required by a const generic parameter in `bar`
-  --> $DIR/type_mismatch.rs:6:8
+  --> $DIR/type_mismatch.rs:7:8
    |
 LL | fn bar<const N: u8>() -> [u8; N] {}
    |        ^^^^^^^^^^^ required by this const generic parameter in `bar`
 
 error[E0308]: mismatched types
-  --> $DIR/type_mismatch.rs:6:26
+  --> $DIR/type_mismatch.rs:7:26
    |
 LL | fn bar<const N: u8>() -> [u8; N] {}
    |    ---                   ^^^^^^^ expected `[u8; N]`, found `()`
    |    |
    |    implicitly returns `()` as its body has no tail or `return` expression
 
-error: aborting due to 3 previous errors
+error[E0308]: mismatched types
+  --> $DIR/type_mismatch.rs:2:11
+   |
+LL |     bar::<N>()
+   |           ^ expected `u8`, found `usize`
+
+error[E0308]: mismatched types
+  --> $DIR/type_mismatch.rs:7:31
+   |
+LL | fn bar<const N: u8>() -> [u8; N] {}
+   |                               ^ expected `usize`, found `u8`
+
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/consts/issue-36163.stderr b/tests/ui/consts/issue-36163.stderr
index 52d3e003f0a..8a7a0981f41 100644
--- a/tests/ui/consts/issue-36163.stderr
+++ b/tests/ui/consts/issue-36163.stderr
@@ -1,10 +1,10 @@
-error[E0391]: cycle detected when simplifying constant for the type system `Foo::{constant#0}`
+error[E0391]: cycle detected when simplifying constant for the type system `Foo::B::{constant#0}`
   --> $DIR/issue-36163.rs:4:9
    |
 LL |     B = A,
    |         ^
    |
-note: ...which requires const-evaluating + checking `Foo::{constant#0}`...
+note: ...which requires const-evaluating + checking `Foo::B::{constant#0}`...
   --> $DIR/issue-36163.rs:4:9
    |
 LL |     B = A,
@@ -19,7 +19,7 @@ note: ...which requires const-evaluating + checking `A`...
    |
 LL | const A: isize = Foo::B as isize;
    |                  ^^^^^^^^^^^^^^^
-   = note: ...which again requires simplifying constant for the type system `Foo::{constant#0}`, completing the cycle
+   = note: ...which again requires simplifying constant for the type system `Foo::B::{constant#0}`, completing the cycle
 note: cycle used when checking that `Foo` is well-formed
   --> $DIR/issue-36163.rs:3:1
    |
diff --git a/tests/ui/feature-gates/feature-gate-const-arg-path.rs b/tests/ui/feature-gates/feature-gate-const-arg-path.rs
new file mode 100644
index 00000000000..0938c5733a2
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-const-arg-path.rs
@@ -0,0 +1,5 @@
+//@ check-pass
+
+// this doesn't really have any user facing impact....
+
+fn main() {}
diff --git a/tests/ui/lifetimes/issue-95023.rs b/tests/ui/lifetimes/issue-95023.rs
index bcacd01474f..8461d92fc33 100644
--- a/tests/ui/lifetimes/issue-95023.rs
+++ b/tests/ui/lifetimes/issue-95023.rs
@@ -2,12 +2,13 @@ struct ErrorKind;
 struct Error(ErrorKind);
 impl Fn(&isize) for Error {
     //~^ ERROR manual implementations of `Fn` are experimental [E0183]
-    //~^^ ERROR associated item constraints are not allowed here [E0229]
+    //~| ERROR associated item constraints are not allowed here [E0229]
     //~| ERROR not all trait items implemented
     //~| ERROR expected a `FnMut(&isize)` closure, found `Error`
     fn foo<const N: usize>(&self) -> Self::B<{ N }>;
     //~^ ERROR associated function in `impl` without body
-    //~^^ ERROR method `foo` is not a member of trait `Fn` [E0407]
-    //~^^^ ERROR associated type `B` not found for `Self` [E0220]
+    //~| ERROR method `foo` is not a member of trait `Fn` [E0407]
+    //~| ERROR associated type `B` not found for `Self` [E0220]
+    //~| ERROR: associated type `B` not found for `Self`
 }
 fn main() {}
diff --git a/tests/ui/lifetimes/issue-95023.stderr b/tests/ui/lifetimes/issue-95023.stderr
index cbc0eeebee1..310dee51406 100644
--- a/tests/ui/lifetimes/issue-95023.stderr
+++ b/tests/ui/lifetimes/issue-95023.stderr
@@ -56,7 +56,15 @@ error[E0220]: associated type `B` not found for `Self`
 LL |     fn foo<const N: usize>(&self) -> Self::B<{ N }>;
    |                                            ^ help: `Self` has the following associated type: `Output`
 
-error: aborting due to 7 previous errors
+error[E0220]: associated type `B` not found for `Self`
+  --> $DIR/issue-95023.rs:8:44
+   |
+LL |     fn foo<const N: usize>(&self) -> Self::B<{ N }>;
+   |                                            ^ help: `Self` has the following associated type: `Output`
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 8 previous errors
 
 Some errors have detailed explanations: E0046, E0183, E0220, E0229, E0277, E0407.
 For more information about an error, try `rustc --explain E0046`.
diff --git a/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs b/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs
index fb962ad24bf..858fba2132a 100644
--- a/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs
+++ b/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs
@@ -14,5 +14,6 @@ struct Wrapper<const C: <i32 as Trait>::Type> {}
 
 impl<const C: usize> Wrapper<C> {}
 //~^ ERROR the constant `C` is not of type `<i32 as Trait>::Type`
+//~| ERROR: mismatched types
 
 fn main() {}
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 7094ee8c67c..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
@@ -20,5 +20,17 @@ note: required by a const generic parameter in `Wrapper`
 LL | struct Wrapper<const C: <i32 as Trait>::Type> {}
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Wrapper`
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:15:30
+   |
+LL | impl<const C: usize> Wrapper<C> {}
+   |                              ^ expected associated type, found `usize`
+   |
+   = note: expected associated type `<i32 as Trait>::Type`
+                         found type `usize`
+   = 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
+
+error: aborting due to 3 previous errors
 
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs b/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs
index a0ee7714417..f89a463bc58 100644
--- a/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs
+++ b/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs
@@ -6,6 +6,7 @@
 struct S<const L: usize>;
 
 impl<const N: i32> Copy for S<N> {}
+//~^ ERROR: mismatched types
 impl<const M: usize> Copy for S<M> {}
 //~^ ERROR: conflicting implementations of trait `Copy` for type `S<_>`
 
diff --git a/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr b/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr
index 2953bc95917..1dac58e1f69 100644
--- a/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr
+++ b/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr
@@ -1,11 +1,19 @@
 error[E0119]: conflicting implementations of trait `Copy` for type `S<_>`
-  --> $DIR/bad-const-wf-doesnt-specialize.rs:9:1
+  --> $DIR/bad-const-wf-doesnt-specialize.rs:10:1
    |
 LL | impl<const N: i32> Copy for S<N> {}
    | -------------------------------- first implementation here
+LL |
 LL | impl<const M: usize> Copy for S<M> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `S<_>`
 
-error: aborting due to 1 previous error
+error[E0308]: mismatched types
+  --> $DIR/bad-const-wf-doesnt-specialize.rs:8:31
+   |
+LL | impl<const N: i32> Copy for S<N> {}
+   |                               ^ expected `usize`, found `i32`
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0119`.
+Some errors have detailed explanations: E0119, E0308.
+For more information about an error, try `rustc --explain E0119`.
diff --git a/tests/ui/transmutability/issue-101739-1.rs b/tests/ui/transmutability/issue-101739-1.rs
index 20bd7917e53..81a9038fdb5 100644
--- a/tests/ui/transmutability/issue-101739-1.rs
+++ b/tests/ui/transmutability/issue-101739-1.rs
@@ -6,7 +6,8 @@ mod assert {
     pub fn is_transmutable<Src, const ASSUME_ALIGNMENT: bool>()
     where
         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, //~ ERROR cannot find type `Dst` in this scope
-        //~^ the constant `ASSUME_ALIGNMENT` is not of type `Assume`
+                                                           //~| the constant `ASSUME_ALIGNMENT` is not of type `Assume`
+                                                           //~| ERROR: mismatched types
     {
     }
 }
diff --git a/tests/ui/transmutability/issue-101739-1.stderr b/tests/ui/transmutability/issue-101739-1.stderr
index ba18a980f4d..6f79bf7b424 100644
--- a/tests/ui/transmutability/issue-101739-1.stderr
+++ b/tests/ui/transmutability/issue-101739-1.stderr
@@ -13,6 +13,13 @@ LL |         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
 note: required by a const generic parameter in `BikeshedIntrinsicFrom`
   --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/issue-101739-1.rs:8:41
+   |
+LL |         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
+   |                                         ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
+
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0412`.
+Some errors have detailed explanations: E0308, E0412.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/transmutability/issue-101739-2.rs b/tests/ui/transmutability/issue-101739-2.rs
index 8b36bf3dcb1..6dfde06d6b3 100644
--- a/tests/ui/transmutability/issue-101739-2.rs
+++ b/tests/ui/transmutability/issue-101739-2.rs
@@ -14,19 +14,23 @@ mod assert {
         const ASSUME_VISIBILITY: bool,
     >()
     where
-        Dst: BikeshedIntrinsicFrom< //~ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
-            Src,
-            ASSUME_ALIGNMENT,
-            ASSUME_LIFETIMES,
-            ASSUME_VALIDITY,
-            ASSUME_VISIBILITY,
-        >,
-    {}
+        Dst: BikeshedIntrinsicFrom<
+                //~^ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
+                Src,
+                ASSUME_ALIGNMENT, //~ ERROR: mismatched types
+                ASSUME_LIFETIMES,
+                ASSUME_VALIDITY,
+                ASSUME_VISIBILITY,
+            >,
+    {
+    }
 }
 
 fn via_const() {
-    #[repr(C)] struct Src;
-    #[repr(C)] struct Dst;
+    #[repr(C)]
+    struct Src;
+    #[repr(C)]
+    struct Dst;
 
     const FALSE: bool = false;
 
diff --git a/tests/ui/transmutability/issue-101739-2.stderr b/tests/ui/transmutability/issue-101739-2.stderr
index 6b0a36a414b..11e8fa1d8c5 100644
--- a/tests/ui/transmutability/issue-101739-2.stderr
+++ b/tests/ui/transmutability/issue-101739-2.stderr
@@ -3,14 +3,21 @@ error[E0107]: trait takes at most 2 generic arguments but 5 generic arguments we
    |
 LL |           Dst: BikeshedIntrinsicFrom<
    |                ^^^^^^^^^^^^^^^^^^^^^ expected at most 2 generic arguments
-LL |               Src,
-LL |               ASSUME_ALIGNMENT,
-   |  _____________________________-
-LL | |             ASSUME_LIFETIMES,
-LL | |             ASSUME_VALIDITY,
-LL | |             ASSUME_VISIBILITY,
-   | |_____________________________- help: remove the unnecessary generic arguments
+...
+LL |                   ASSUME_ALIGNMENT,
+   |  _________________________________-
+LL | |                 ASSUME_LIFETIMES,
+LL | |                 ASSUME_VALIDITY,
+LL | |                 ASSUME_VISIBILITY,
+   | |_________________________________- help: remove the unnecessary generic arguments
 
-error: aborting due to 1 previous error
+error[E0308]: mismatched types
+  --> $DIR/issue-101739-2.rs:20:17
+   |
+LL |                 ASSUME_ALIGNMENT,
+   |                 ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0107`.
+Some errors have detailed explanations: E0107, E0308.
+For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
index 9fc249198d0..92c1999e154 100644
--- a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
+++ b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
@@ -3,16 +3,18 @@
 // of an impl fn produces a type mismatch error instead of triggering
 // a const eval cycle
 
-
 trait Trait {
-    fn func<const N: u32>() -> [ (); N ]; //~ ERROR the constant `N` is not of type `usize`
+    fn func<const N: u32>() -> [(); N];
+    //~^ ERROR: the constant `N` is not of type `usize`
+    //~| ERROR: mismatched types
 }
 
 struct S {}
 
 #[allow(unused_braces)]
 impl Trait for S {
-    fn func<const N: u32>() -> [ (); { () }] { //~ ERROR mismatched types
+    fn func<const N: u32>() -> [(); { () }] {
+        //~^ ERROR mismatched types
         N
     }
 }
diff --git a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
index bff926a2081..bb8025d47a1 100644
--- a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
+++ b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
@@ -1,15 +1,21 @@
 error[E0308]: mismatched types
-  --> $DIR/const-in-impl-fn-return-type.rs:15:40
+  --> $DIR/const-in-impl-fn-return-type.rs:16:39
    |
-LL |     fn func<const N: u32>() -> [ (); { () }] {
-   |                                        ^^ expected `usize`, found `()`
+LL |     fn func<const N: u32>() -> [(); { () }] {
+   |                                       ^^ expected `usize`, found `()`
 
 error: the constant `N` is not of type `usize`
-  --> $DIR/const-in-impl-fn-return-type.rs:8:32
+  --> $DIR/const-in-impl-fn-return-type.rs:7:32
    |
-LL |     fn func<const N: u32>() -> [ (); N ];
-   |                                ^^^^^^^^^ expected `usize`, found `u32`
+LL |     fn func<const N: u32>() -> [(); N];
+   |                                ^^^^^^^ expected `usize`, found `u32`
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/const-in-impl-fn-return-type.rs:7:37
+   |
+LL |     fn func<const N: u32>() -> [(); N];
+   |                                     ^ expected `usize`, found `u32`
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0308`.