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
- || !expr.is_potential_trivial_const_arg()
- {
+ if !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
- && let Some(res) = maybe_res
+ if 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(
- qpath @ hir::QPath::Resolved(
- _,
- &hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
- ),
- ) = expr.kind
+ if let hir::ExprKind::Path(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));
+ span_bug!(expr.span, "try_from_lit: received const param which shouldn't be possible");
  };
 
  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
- // 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 matches!(constant.value.maybe_unwrap_block().kind, ExprKind::MacCall(..)) {
- // See self.pending_anon_const_info for explanation
- self.pending_anon_const_info =
- Some(PendingAnonConstInfo { id: constant.id, span: constant.value.span });
- return visit::walk_anon_const(self, constant);
- } else if constant.value.is_potential_trivial_const_arg() {
- return visit::walk_anon_const(self, constant);
- }
+ // 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 matches!(constant.value.maybe_unwrap_block().kind, ExprKind::MacCall(..)) {
+ // See self.pending_anon_const_info for explanation
+ self.pending_anon_const_info =
+ Some(PendingAnonConstInfo { id: constant.id, span: constant.value.span });
+ return visit::walk_anon_const(self, constant);
+ } else if constant.value.is_potential_trivial_const_arg() {
+ 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/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
- --> $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
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0119, E0308.
-For more information about an error, try `rustc --explain E0119`.
+For more information about this 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
- --> $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
+error: aborting due to 2 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
- --> $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
+error: aborting due to 4 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

@@ -26,8 +26,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#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#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:28: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:28: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`