Re-enable ConstArgKind::Path lowering by default

...and remove the `const_arg_path` feature gate as a result. It was only
a stopgap measure to fix the regression that the new lowering introduced
(which should now be fixed by this PR).

compiler/rustc_ast_lowering/src/asm.rs

@@ -220,9 +220,7 @@ 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 !self.tcx.features().const_arg_path
+                            if !expr.is_potential_trivial_const_arg() {
-                                || !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 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let node_id = self.next_node_id();
 
                 // HACK(min_generic_const_args): see lower_anon_const
-                if !self.tcx.features().const_arg_path || !arg.is_potential_trivial_const_arg() {
+                if !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

@@ -2335,7 +2335,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         span: Span,
     ) -> &'hir hir::ConstArg<'hir> {
         let ct_kind = match res {
-            Res::Def(DefKind::ConstParam, _) if self.tcx.features().const_arg_path => {
+            Res::Def(DefKind::ConstParam, _) => {
                 let qpath = self.lower_qpath(
                     ty_id,
                     &None,
@@ -2410,8 +2410,7 @@ 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 self.tcx.features().const_arg_path
+        if let Some(res) = maybe_res
-            && let Some(res) = maybe_res
             && let Res::Def(DefKind::ConstParam, _) = res
             && let ExprKind::Path(qself, path) = &expr.kind
         {
@@ -2442,7 +2441,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 self.tcx.features().const_arg_path && c.value.is_potential_trivial_const_arg() {
+        if 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,8 +193,6 @@ 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

compiler/rustc_middle/src/ty/consts.rs

@@ -295,20 +295,12 @@ impl<'tcx> Const<'tcx> {
             _ => expr,
         };
 
-        if let hir::ExprKind::Path(
+        if let hir::ExprKind::Path(hir::QPath::Resolved(
-            qpath @ hir::QPath::Resolved(
+            _,
-                _,
+            &hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
-                &hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
+        )) = expr.kind
-            ),
-        ) = expr.kind
         {
-            if tcx.features().const_arg_path {
+            span_bug!(expr.span, "try_from_lit: received const param which shouldn't be possible");
-                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 {

compiler/rustc_resolve/src/def_collector.rs

@@ -347,22 +347,20 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
     }
 
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
-        if self.resolver.tcx.features().const_arg_path {
+        // HACK(min_generic_const_args): don't create defs for anon consts if we think they will
-            // 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
-            // 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
-            // 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
-            // 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
-            // items will be messed up, but that's ok because there can't be any if we're just looking
+        // for bare idents.
-            // for bare idents.
 
-            if matches!(constant.value.maybe_unwrap_block().kind, ExprKind::MacCall(..)) {
+        if matches!(constant.value.maybe_unwrap_block().kind, ExprKind::MacCall(..)) {
-                // See self.pending_anon_const_info for explanation
+            // See self.pending_anon_const_info for explanation
-                self.pending_anon_const_info =
+            self.pending_anon_const_info =
-                    Some(PendingAnonConstInfo { id: constant.id, span: constant.value.span });
+                Some(PendingAnonConstInfo { id: constant.id, span: constant.value.span });
-                return visit::walk_anon_const(self, constant);
+            return visit::walk_anon_const(self, constant);
-            } else if constant.value.is_potential_trivial_const_arg() {
+        } else if constant.value.is_potential_trivial_const_arg() {
-                return visit::walk_anon_const(self, constant);
+            return visit::walk_anon_const(self, constant);
-            }
         }
 
         let def = self.create_def(constant.id, kw::Empty, DefKind::AnonConst, constant.value.span);

compiler/rustc_span/src/symbol.rs

@@ -599,7 +599,6 @@ symbols! {
         conservative_impl_trait,
         console,
         const_allocate,
-        const_arg_path,
         const_async_blocks,
         const_closures,
         const_compare_raw_pointers,

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

@@ -35,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(), 4, "Expected 3 mono functions");
+    assert_eq!(mono.len(), 3, "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,9 +5,7 @@
 #![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,25 +1,11 @@
 error[E0119]: conflicting implementations of trait `Trait` for type `[(); _]`
-  --> $DIR/generic_const_type_mismatch.rs:9:1
+  --> $DIR/generic_const_type_mismatch.rs:8: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[E0308]: mismatched types
+error: aborting due to 1 previous error
-  --> $DIR/generic_const_type_mismatch.rs:7:34
-   |
-LL | impl<const N: u8> Trait for [(); N] {}
-   |                                  ^ expected `usize`, found `u8`
 
-error[E0308]: mismatched types
+For more information about this error, try `rustc --explain E0119`.
-  --> $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,7 +7,6 @@ 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:14:24
+  --> $DIR/bad-subst-const-kind.rs:13:24
    |
 LL | pub fn test() -> [u8; <[u8; 13] as Q>::ASSOC] {
    |                        ^^^^^^^^ expected `u64`, found `usize`
@@ -18,12 +18,5 @@ LL | impl<const N: u64> Q for [u8; N] {
    |      |
    |      unsatisfied trait bound introduced here
 
-error[E0308]: mismatched types
+error: aborting due to 2 previous errors
-  --> $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/generic_const_exprs/type_mismatch.rs

@@ -8,7 +8,6 @@ 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:13:26
+  --> $DIR/type_mismatch.rs:12:26
    |
 LL | pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
    |                          ^^^^^^^^ expected `u64`, found `usize`
@@ -28,20 +28,14 @@ LL | impl<const N: u64> Q for [u8; N] {}
    |      unsatisfied trait bound introduced here
 
 error[E0308]: mismatched types
-  --> $DIR/type_mismatch.rs:13:20
+  --> $DIR/type_mismatch.rs:12: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[E0308]: mismatched types
+error: aborting due to 4 previous errors
-  --> $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

@@ -25,8 +25,8 @@ mod v20 {
     }
 
     impl<const v10: usize> v17<v10, v2> {
-        //~^ 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#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#0}
         pub const fn v21() -> v18 {
             //~^ ERROR cannot find type `v18` in this scope
             v18 { _p: () }

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#1}
+error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
   --> $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#1}
+error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
   --> $DIR/unevaluated-const-ice-119731.rs:27:37
    |
 LL |     impl<const v10: usize> v17<v10, v2> {

tests/ui/const-generics/transmute-fail.rs

@@ -11,8 +11,6 @@ fn foo<const W: usize, const H: usize>(v: [[u32; H + 1]; W]) -> [[u32; W + 1]; H
 
 fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
     //~^ 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`

tests/ui/const-generics/transmute-fail.stderr

@@ -14,13 +14,13 @@ LL |         std::mem::transmute(v)
    = 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:17:9
+  --> $DIR/transmute-fail.rs:15:9
    |
 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:24:9
+  --> $DIR/transmute-fail.rs:22:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |         std::mem::transmute(v)
    = 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:31:9
+  --> $DIR/transmute-fail.rs:29:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL |         std::mem::transmute(v)
    = 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:38:9
+  --> $DIR/transmute-fail.rs:36:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -47,7 +47,7 @@ LL |         std::mem::transmute(v)
    = 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:9
+  --> $DIR/transmute-fail.rs:47:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |         std::mem::transmute(v)
    = 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:9
+  --> $DIR/transmute-fail.rs:54:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |         std::mem::transmute(v)
    = 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:9
+  --> $DIR/transmute-fail.rs:63:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ LL |         std::mem::transmute(v)
    = 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:9
+  --> $DIR/transmute-fail.rs:72:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL |         std::mem::transmute(v)
    = 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:9
+  --> $DIR/transmute-fail.rs:79:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -92,7 +92,7 @@ LL |         std::mem::transmute(v)
    = 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:9
+  --> $DIR/transmute-fail.rs:86:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -101,7 +101,7 @@ LL |         std::mem::transmute(v)
    = 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:9
+  --> $DIR/transmute-fail.rs:93:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -110,7 +110,7 @@ LL |         std::mem::transmute(v)
    = 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:9
+  --> $DIR/transmute-fail.rs:102:9
    |
 LL |         std::mem::transmute(v)
    |         ^^^^^^^^^^^^^^^^^^^
@@ -118,19 +118,6 @@ 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[E0308]: mismatched types
+error: aborting due to 14 previous errors
-  --> $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
+For more information about this error, try `rustc --explain E0512`.
-  --> $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,12 +1,10 @@
 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:7:26
+  --> $DIR/type_mismatch.rs:6:26
    |
 LL | fn bar<const N: u8>() -> [u8; N] {}
    |                          ^^^^^^^ expected `usize`, found `u8`
@@ -11,31 +11,19 @@ LL |     bar::<N>()
    |           ^ expected `u8`, found `usize`
    |
 note: required by a const generic parameter in `bar`
-  --> $DIR/type_mismatch.rs:7:8
+  --> $DIR/type_mismatch.rs:6: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:7:26
+  --> $DIR/type_mismatch.rs:6: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[E0308]: mismatched types
+error: aborting due to 3 previous errors
-  --> $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::B::{constant#0}`
+error[E0391]: cycle detected when simplifying constant for the type system `Foo::{constant#0}`
   --> $DIR/issue-36163.rs:4:9
    |
 LL |     B = A,
    |         ^
    |
-note: ...which requires const-evaluating + checking `Foo::B::{constant#0}`...
+note: ...which requires const-evaluating + checking `Foo::{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::B::{constant#0}`, completing the cycle
+   = note: ...which again requires simplifying constant for the type system `Foo::{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

@@ -1,5 +0,0 @@
-//@ check-pass
-
-// this doesn't really have any user facing impact....
-
-fn main() {}

tests/ui/lifetimes/issue-95023.rs

@@ -9,6 +9,5 @@ impl Fn(&isize) for Error {
     //~^ 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: associated type `B` not found for `Self`
 }
 fn main() {}

tests/ui/lifetimes/issue-95023.stderr

@@ -56,15 +56,7 @@ 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[E0220]: associated type `B` not found for `Self`
+error: aborting due to 7 previous errors
-  --> $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,6 +14,5 @@ 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,17 +20,5 @@ 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[E0308]: mismatched types
+error: aborting due to 2 previous errors
-  --> $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,7 +6,6 @@
 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,19 +1,11 @@
 error[E0119]: conflicting implementations of trait `Copy` for type `S<_>`
-  --> $DIR/bad-const-wf-doesnt-specialize.rs:10:1
+  --> $DIR/bad-const-wf-doesnt-specialize.rs:9: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[E0308]: mismatched types
+error: aborting due to 1 previous error
-  --> $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`.

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

@@ -7,7 +7,6 @@ mod assert {
     where
         Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>, //~ ERROR cannot find type `Dst` in this scope
                                                            //~| the constant `ASSUME_ALIGNMENT` is not of type `Assume`
-                                                           //~| ERROR: mismatched types
     {
     }
 }

tests/ui/transmutability/issue-101739-1.stderr

@@ -13,13 +13,6 @@ LL |         Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>,
 note: required by a const generic parameter in `TransmuteFrom`
   --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
 
-error[E0308]: mismatched types
+error: aborting due to 2 previous errors
-  --> $DIR/issue-101739-1.rs:8:33
-   |
-LL |         Dst: TransmuteFrom<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`.

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

@@ -17,7 +17,7 @@ mod assert {
         Dst: TransmuteFrom<
                 //~^ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
                 Src,
-                ASSUME_ALIGNMENT, //~ ERROR: mismatched types
+                ASSUME_ALIGNMENT,
                 ASSUME_LIFETIMES,
                 ASSUME_VALIDITY,
                 ASSUME_VISIBILITY,

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

@@ -11,13 +11,6 @@ LL | |                 ASSUME_VALIDITY,
 LL | |                 ASSUME_VISIBILITY,
    | |_________________________________- help: remove the unnecessary generic arguments
 
-error[E0308]: mismatched types
+error: aborting due to 1 previous error
-  --> $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`.

tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs

@@ -6,7 +6,6 @@
 trait Trait {
     fn func<const N: u32>() -> [(); N];
     //~^ ERROR: the constant `N` is not of type `usize`
-    //~| ERROR: mismatched types
 }
 
 struct S {}

tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr

@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/const-in-impl-fn-return-type.rs:16:39
+  --> $DIR/const-in-impl-fn-return-type.rs:15:39
    |
 LL |     fn func<const N: u32>() -> [(); { () }] {
    |                                       ^^ expected `usize`, found `()`
@@ -10,12 +10,6 @@ error: the constant `N` is not of type `usize`
 LL |     fn func<const N: u32>() -> [(); N];
    |                                ^^^^^^^ expected `usize`, found `u32`
 
-error[E0308]: mismatched types
+error: aborting due to 2 previous errors
-  --> $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`.