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

compiler/rustc_ast_lowering/src/asm.rs

@@ -220,7 +220,9 @@ pub(crate) fn lower_inline_asm(
                             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,

compiler/rustc_ast_lowering/src/expr.rs

@@ -387,7 +387,7 @@ fn lower_legacy_const_generics(
                 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);
                 }

compiler/rustc_ast_lowering/src/lib.rs

@@ -2358,7 +2358,7 @@ fn lower_const_path_to_const_arg(
         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 @@ fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::Con
             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 @@ fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::Con
     /// 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)

compiler/rustc_feature/src/unstable.rs

@@ -193,6 +193,8 @@ pub fn internal(&self, feature: Symbol) -> bool {
     (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

compiler/rustc_middle/src/ty/consts.rs

@@ -240,7 +240,7 @@ pub fn from_anon_const(tcx: TyCtxt<'tcx>, def: LocalDefId) -> Self {
 
         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 @@ fn from_param(tcx: TyCtxt<'tcx>, qpath: hir::QPath<'tcx>, hir_id: HirId) -> Self
     }
 
     #[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 @@ fn try_from_lit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'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 @@ fn try_from_lit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'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
     }
 

compiler/rustc_resolve/src/def_collector.rs

@@ -314,13 +314,15 @@ fn visit_pat(&mut self, pat: &'a Pat) {
     }
 
     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 =

compiler/rustc_span/src/symbol.rs

@@ -595,6 +595,7 @@
         conservative_impl_trait,
         console,
         const_allocate,
+        const_arg_path,
         const_async_blocks,
         const_closures,
         const_compare_raw_pointers,

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) }])

tests/crashes/128016.rs

@@ -1,10 +0,0 @@
-//@ known-bug: #128016
-macro_rules! len {
-    () => {
-        target
-    };
-}
-
-fn main() {
-    let val: [str; len!()] = [];
-}

tests/ui-fulldeps/stable-mir/check_instance.rs

@@ -17,12 +17,14 @@
 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.

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() {}

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`
 
-For more information about this error, try `rustc --explain E0119`.
+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
+
+Some errors have detailed explanations: E0119, E0308.
+For more information about an error, try `rustc --explain E0119`.

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;
 }
 

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`.

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!()] = [];
+}

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() {}

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
+}

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`.

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!()] = [];
+}

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`

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`.

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 @@ pub const fn v21() -> v18 {}
     }
 
     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
         }

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> {

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() {}

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`
 
-For more information about this error, try `rustc --explain E0512`.
+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
+
+Some errors have detailed explanations: E0308, E0512.
+For more information about an error, try `rustc --explain E0308`.

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() {}

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`.

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
    |

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() {}

tests/ui/lifetimes/issue-95023.rs

@@ -2,12 +2,13 @@
 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() {}

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`.

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() {}

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`.

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<_>`
 

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`
 
-For more information about this error, try `rustc --explain E0119`.
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0119, E0308.
+For more information about an error, try `rustc --explain E0119`.

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
     {
     }
 }

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`
 
-For more information about this error, try `rustc --explain E0412`.
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0308, E0412.
+For more information about an error, try `rustc --explain E0308`.

tests/ui/transmutability/issue-101739-2.rs

@@ -14,19 +14,23 @@ pub fn is_transmutable<
         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;
 

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`
 
-For more information about this error, try `rustc --explain E0107`.
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0107, E0308.
+For more information about an error, try `rustc --explain E0107`.

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
     }
 }

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`.