generic_const_args: allow paths to non type consts

khyperia · khyperia · commit 9e4f9d26b91c · 2026-04-28T10:19:14.000+02:00
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -3041,7 +3041,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         span: Span,
     ) -> Result<(), ErrorGuaranteed> {
         let tcx = self.tcx();
-        if tcx.is_type_const(def_id) {
+        // FIXME(gca): Intentionally disallowing paths to inherent associated non-type constants
+        // until a refactoring for how generic args for IACs are represented has been landed.
+        let is_inherent_assoc_const = tcx.def_kind(def_id)
+            == DefKind::AssocConst { is_type_const: false }
+            && tcx.def_kind(tcx.parent(def_id)) == DefKind::Impl { of_trait: false };
+        if tcx.is_type_const(def_id)
+            || tcx.features().generic_const_args() && !is_inherent_assoc_const
+        {
             Ok(())
         } else {
             let mut err = self.dcx().struct_span_err(
diff --git a/compiler/rustc_middle/src/ty/context/impl_interner.rs b/compiler/rustc_middle/src/ty/context/impl_interner.rs
@@ -177,6 +177,9 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     fn type_of_opaque_hir_typeck(self, def_id: LocalDefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {
         self.type_of_opaque_hir_typeck(def_id)
     }
+    fn is_type_const(self, def_id: DefId) -> bool {
+        self.is_type_const(def_id)
+    }
     fn const_of_item(self, def_id: DefId) -> ty::EarlyBinder<'tcx, Const<'tcx>> {
         self.const_of_item(def_id)
     }
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -1168,6 +1168,40 @@ where
         self.delegate.evaluate_const(param_env, uv)
     }
 
+    pub(super) fn evaluate_const_and_instantiate_normalizes_to_term(
+        &mut self,
+        goal: Goal<I, ty::NormalizesTo<I>>,
+        uv: ty::UnevaluatedConst<I>,
+    ) -> QueryResult<I> {
+        match self.evaluate_const(goal.param_env, uv) {
+            Some(evaluated) => {
+                self.instantiate_normalizes_to_term(goal, evaluated.into());
+                self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+            }
+            None => {
+                // HACK(khyperia): calling `resolve_vars_if_possible` here shouldn't be necessary,
+                // `try_evaluate_const` calls `resolve_vars_if_possible` already. However, we want
+                // to check `has_non_region_infer` against the type with vars resolved (i.e. check
+                // if there are vars we failed to resolve), so we need to call it again here.
+                // Perhaps we could split EvaluateConstErr::HasGenericsOrInfers into HasGenerics and
+                // HasInfers or something, make evaluate_const return that, and make this branch be
+                // based on that, rather than checking `has_non_region_infer`.
+                if self.resolve_vars_if_possible(uv).has_non_region_infer() {
+                    self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
+                } else {
+                    // We do not instantiate to the `uv` passed in, but rather
+                    // `goal.predicate.alias`. The `uv` passed in might correspond to the `impl`
+                    // form of a constant (with generic arguments corresponding to the impl block),
+                    // however, we want to structurally instantiate to the original, non-rebased,
+                    // trait `Self` form of the constant (with generic arguments being the trait
+                    // `Self` type).
+                    self.structurally_instantiate_normalizes_to_term(goal, goal.predicate.alias);
+                    self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+                }
+            }
+        }
+    }
+
     pub(super) fn is_transmutable(
         &mut self,
         src: I::Ty,
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs
@@ -14,17 +14,23 @@ where
         &mut self,
         goal: Goal<I, ty::NormalizesTo<I>>,
     ) -> QueryResult<I> {
-        if let Some(normalized_const) = self.evaluate_const(
-            goal.param_env,
-            ty::UnevaluatedConst::new(
-                goal.predicate.alias.def_id().try_into().unwrap(),
-                goal.predicate.alias.args,
-            ),
-        ) {
-            self.instantiate_normalizes_to_term(goal, normalized_const.into());
-            self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+        let cx = self.cx();
+        let uv = goal.predicate.alias.expect_ct(self.cx());
+        // keep legacy behavior for array repeat expressions:
+        // when a constant is too generic to be evaluated, the legacy behavior is to return
+        // Ambiguous, whereas evaluate_const_and_instantiate_normalizes_to_term structurally
+        // instantiates to itself and returns Yes (if there are no inference variables)
+        let is_repeat_expr =
+            cx.anon_const_kind(uv.def.into()) == ty::AnonConstKind::RepeatExprCount;
+        if is_repeat_expr {
+            if let Some(normalized_const) = self.evaluate_const(goal.param_env, uv) {
+                self.instantiate_normalizes_to_term(goal, normalized_const.into());
+                self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+            } else {
+                self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
+            }
         } else {
-            self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
+            self.evaluate_const_and_instantiate_normalizes_to_term(goal, uv)
         }
     }
 }
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/free_alias.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/free_alias.rs
@@ -34,9 +34,15 @@ where
             ty::AliasTermKind::FreeTy { def_id } => {
                 cx.type_of(def_id).instantiate(cx, free_alias.args).skip_norm_wip().into()
             }
-            ty::AliasTermKind::FreeConst { def_id } => {
+            ty::AliasTermKind::FreeConst { def_id } if cx.is_type_const(def_id) => {
                 cx.const_of_item(def_id).instantiate(cx, free_alias.args).skip_norm_wip().into()
             }
+            ty::AliasTermKind::FreeConst { .. } => {
+                return self.evaluate_const_and_instantiate_normalizes_to_term(
+                    goal,
+                    free_alias.expect_ct(cx),
+                );
+            }
             kind => panic!("expected free alias, found {kind:?}"),
         };
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs
@@ -56,9 +56,18 @@ where
             ty::AliasTermKind::InherentTy { def_id } => {
                 cx.type_of(def_id).instantiate(cx, inherent_args).skip_norm_wip().into()
             }
-            ty::AliasTermKind::InherentConst { def_id } => {
+            ty::AliasTermKind::InherentConst { def_id } if cx.is_type_const(def_id) => {
                 cx.const_of_item(def_id).instantiate(cx, inherent_args).skip_norm_wip().into()
             }
+            ty::AliasTermKind::InherentConst { .. } => {
+                // FIXME(gca): This is dead code at the moment. It should eventually call
+                // self.evaluate_const like projected consts do in consider_impl_candidate in
+                // normalizes_to/mod.rs. However, how generic args are represented for IACs is up in
+                // the air right now.
+                // Will self.evaluate_const eventually take the inherent_args or the impl_args form
+                // of args? It might be either.
+                panic!("References to inherent associated consts should have been blocked");
+            }
             kind => panic!("expected inherent alias, found {kind:?}"),
         };
         self.instantiate_normalizes_to_term(goal, normalized);
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -389,11 +389,28 @@ where
                     .instantiate(cx, target_args)
                     .skip_norm_wip()
                     .into(),
-                ty::AliasTermKind::ProjectionConst { .. } => cx
-                    .const_of_item(target_item_def_id)
-                    .instantiate(cx, target_args)
-                    .skip_norm_wip()
-                    .into(),
+                ty::AliasTermKind::ProjectionConst { .. }
+                    if cx.is_type_const(target_item_def_id) =>
+                {
+                    cx.const_of_item(target_item_def_id)
+                        .instantiate(cx, target_args)
+                        .skip_norm_wip()
+                        .into()
+                }
+                ty::AliasTermKind::ProjectionConst { .. } => {
+                    // target_args contains vars:
+                    // - the Self type of the impl block is instantiated with fresh vars
+                    // - the resulting type is eq'd against the actual Self type
+                    // - the fresh vars are then used as target_args
+                    // we need the actual args to run const eval, so we need to actually do the `eq`
+                    // and figure out the args, so, call try_evaluate_added_goals
+                    ecx.try_evaluate_added_goals()?;
+                    let uv = ty::UnevaluatedConst::new(
+                        target_item_def_id.try_into().unwrap(),
+                        target_args,
+                    );
+                    return ecx.evaluate_const_and_instantiate_normalizes_to_term(goal, uv);
+                }
                 kind => panic!("expected projection, found {kind:?}"),
             };
 
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -696,7 +696,10 @@ pub fn try_evaluate_const<'tcx>(
                     // logic does not go through type system normalization. If it did this would
                     // be a backwards compatibility problem as we do not enforce "syntactic" non-
                     // usage of generic parameters like we do here.
-                    if uv.args.has_non_region_param() || uv.args.has_non_region_infer() {
+                    if uv.args.has_non_region_param()
+                        || uv.args.has_non_region_infer()
+                        || uv.args.has_non_region_placeholders()
+                    {
                         return Err(EvaluateConstErr::HasGenericsOrInfers);
                     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/normalize.rs b/compiler/rustc_trait_selection/src/traits/normalize.rs
@@ -347,13 +347,17 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
                 .skip_norm_wip()
                 .fold_with(self)
                 .into(),
-            ty::AliasTermKind::FreeConst { def_id } => infcx
+            ty::AliasTermKind::FreeConst { def_id } if infcx.tcx.is_type_const(def_id) => infcx
                 .tcx
                 .const_of_item(def_id)
                 .instantiate(infcx.tcx, free.args)
                 .skip_norm_wip()
                 .fold_with(self)
                 .into(),
+            ty::AliasTermKind::FreeConst { .. } => {
+                super::evaluate_const(infcx, free.to_term(infcx.tcx).expect_const(), self.param_env)
+                    .into()
+            }
             kind => panic!("expected free alias, found {kind:?}"),
         };
         self.depth -= 1;
@@ -376,6 +380,7 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
         t
     }
 
+    #[instrument(skip(self), level = "debug")]
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
         if !needs_normalization(self.selcx.infcx, &ty) {
             return ty;
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -549,9 +549,17 @@ pub fn normalize_inherent_projection<'a, 'b, 'tcx>(
         ty::AliasTermKind::InherentTy { def_id } => {
             tcx.type_of(def_id).instantiate(tcx, args).skip_norm_wip().into()
         }
-        ty::AliasTermKind::InherentConst { def_id } => {
+        ty::AliasTermKind::InherentConst { def_id } if tcx.is_type_const(def_id) => {
             tcx.const_of_item(def_id).instantiate(tcx, args).skip_norm_wip().into()
         }
+        ty::AliasTermKind::InherentConst { .. } => {
+            // FIXME(gca): This is dead code at the moment. It should eventually call
+            // super::evaluate_const like projected consts do in confirm_impl_candidate in this
+            // file. However, how generic args are represented for IACs is up in the air right now.
+            // Will super::evaluate_const eventually take the inherent_args or the impl_args form of
+            // args? It might be either.
+            panic!("References to inherent associated consts should have been blocked");
+        }
         kind => panic!("expected inherent alias, found {kind:?}"),
     };
 
@@ -617,11 +625,13 @@ pub fn compute_inherent_assoc_term_args<'a, 'b, 'tcx>(
     alias_term.rebase_inherent_args_onto_impl(impl_args, tcx)
 }
 
+#[derive(Debug)]
 enum Projected<'tcx> {
     Progress(Progress<'tcx>),
     NoProgress(ty::Term<'tcx>),
 }
 
+#[derive(Debug)]
 struct Progress<'tcx> {
     term: ty::Term<'tcx>,
     obligations: PredicateObligations<'tcx>,
@@ -652,7 +662,7 @@ impl<'tcx> Progress<'tcx> {
 /// IMPORTANT:
 /// - `obligation` must be fully normalized
 // FIXME(mgca): While this supports constants, it is only used for types by default right now
-#[instrument(level = "info", skip(selcx))]
+#[instrument(level = "info", ret, skip(selcx))]
 fn project<'cx, 'tcx>(
     selcx: &mut SelectionContext<'cx, 'tcx>,
     obligation: &ProjectionTermObligation<'tcx>,
@@ -2060,7 +2070,21 @@ fn confirm_impl_candidate<'cx, 'tcx>(
             ty::AliasTermKind::ProjectionConst { .. } => {
                 let uv = ty::UnevaluatedConst::new(assoc_term.item.def_id, args);
                 let ct = ty::Const::new_unevaluated(tcx, uv);
-                super::evaluate_const(selcx.infcx, ct, param_env).into()
+                // We don't want to use super::evaluate_const, because that returns its parameter
+                // unchanged if it is too generic to evaluate. We are passing the `impl` form of the
+                // constant to evaluate_const (with generic arguments corresponding to the impl
+                // block), but we want to return the original, non-rebased, trait `Self` form of the
+                // constant (with generic arguments being the trait `Self` type) in Projected::NoProgress.
+                match super::try_evaluate_const(selcx.infcx, ct, param_env) {
+                    Ok(evaluated) => evaluated.into(),
+                    Err(
+                        super::EvaluateConstErr::EvaluationFailure(e)
+                        | super::EvaluateConstErr::InvalidConstParamTy(e),
+                    ) => ty::Const::new_error(tcx, e).into(),
+                    Err(super::EvaluateConstErr::HasGenericsOrInfers) => {
+                        return Ok(Projected::NoProgress(obligation.predicate.to_term(tcx)));
+                    }
+                }
             }
             kind => panic!("expected projection alias, found {kind:?}"),
         };
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -1060,7 +1060,7 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
             ty::ConstKind::Unevaluated(uv) => {
                 if !c.has_escaping_bound_vars() {
                     // Skip type consts as mGCA doesn't support evaluatable clauses
-                    if !tcx.is_type_const(uv.def) {
+                    if !tcx.is_type_const(uv.def) && !tcx.features().generic_const_args() {
                         let predicate = ty::Binder::dummy(ty::PredicateKind::Clause(
                             ty::ClauseKind::ConstEvaluatable(c),
                         ));
diff --git a/compiler/rustc_traits/src/normalize_projection_ty.rs b/compiler/rustc_traits/src/normalize_projection_ty.rs
@@ -90,9 +90,13 @@ fn normalize_canonicalized_free_alias<'tcx>(
                 ty::AliasTermKind::FreeTy { def_id } => {
                     tcx.type_of(def_id).instantiate(tcx, goal.args).skip_norm_wip().into()
                 }
-                ty::AliasTermKind::FreeConst { def_id } => {
+                ty::AliasTermKind::FreeConst { def_id } if tcx.is_type_const(def_id) => {
                     tcx.const_of_item(def_id).instantiate(tcx, goal.args).skip_norm_wip().into()
                 }
+                ty::AliasTermKind::FreeConst { .. } => {
+                    traits::evaluate_const(ocx.infcx, goal.to_term(tcx).expect_const(), param_env)
+                        .into()
+                }
                 kind => panic!("expected free alias, found {kind:?}"),
             };
             Ok(NormalizationResult { normalized_term })
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
@@ -205,6 +205,7 @@ pub trait Interner:
     fn type_of(self, def_id: Self::DefId) -> ty::EarlyBinder<Self, Self::Ty>;
     fn type_of_opaque_hir_typeck(self, def_id: Self::LocalDefId)
     -> ty::EarlyBinder<Self, Self::Ty>;
+    fn is_type_const(self, def_id: Self::DefId) -> bool;
     fn const_of_item(self, def_id: Self::DefId) -> ty::EarlyBinder<Self, Self::Const>;
     fn anon_const_kind(self, def_id: Self::DefId) -> ty::AnonConstKind;
 
diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs
@@ -732,16 +732,32 @@ impl<I: Interner> AliasTerm<I> {
             AliasTermKind::InherentTy { def_id } => AliasTyKind::Inherent { def_id },
             AliasTermKind::OpaqueTy { def_id } => AliasTyKind::Opaque { def_id },
             AliasTermKind::FreeTy { def_id } => AliasTyKind::Free { def_id },
-            AliasTermKind::InherentConst { .. }
+            kind @ (AliasTermKind::InherentConst { .. }
             | AliasTermKind::FreeConst { .. }
             | AliasTermKind::UnevaluatedConst { .. }
-            | AliasTermKind::ProjectionConst { .. } => {
-                panic!("Cannot turn `UnevaluatedConst` into `AliasTy`")
+            | AliasTermKind::ProjectionConst { .. }) => {
+                panic!("Cannot turn `{}` into `AliasTy`", kind.descr())
             }
         };
         ty::AliasTy { kind, args: self.args, _use_alias_ty_new_instead: () }
     }
 
+    pub fn expect_ct(self, interner: I) -> ty::UnevaluatedConst<I> {
+        let def_id = match self.kind(interner) {
+            AliasTermKind::InherentConst { def_id }
+            | AliasTermKind::FreeConst { def_id }
+            | AliasTermKind::UnevaluatedConst { def_id }
+            | AliasTermKind::ProjectionConst { def_id } => def_id,
+            kind @ (AliasTermKind::ProjectionTy { .. }
+            | AliasTermKind::InherentTy { .. }
+            | AliasTermKind::OpaqueTy { .. }
+            | AliasTermKind::FreeTy { .. }) => {
+                panic!("Cannot turn `{}` into `UnevaluatedConst`", kind.descr())
+            }
+        };
+        ty::UnevaluatedConst { def: def_id.try_into().unwrap(), args: self.args }
+    }
+
     // FIXME: remove this function (access the field instead)
     pub fn kind(self, _interner: I) -> AliasTermKind<I> {
         self.kind
diff --git a/tests/ui/const-generics/gca/generic-free-const.rs b/tests/ui/const-generics/gca/generic-free-const.rs
@@ -0,0 +1,20 @@
+//@ check-pass
+//@ revisions: old next
+//@[next] compile-flags: -Znext-solver
+
+#![feature(min_generic_const_args)]
+#![feature(generic_const_args)]
+#![feature(generic_const_items)]
+#![expect(incomplete_features)]
+
+const ADD1<const N: usize>: usize = N + 1;
+
+fn a<const N: usize>() -> [usize; ADD1::<N>] {
+    [ADD1::<N>; ADD1::<N>]
+}
+
+fn main() {
+    let _: [(); ADD1::<1>] = [(); ADD1::<1>];
+    let _: [(); ADD1::<{ ADD1::<1> }>] = [(); ADD1::<2>];
+    a::<2>();
+}
diff --git a/tests/ui/const-generics/gca/non-type-equality-fail.next.stderr b/tests/ui/const-generics/gca/non-type-equality-fail.next.stderr
@@ -0,0 +1,25 @@
+error[E0308]: mismatched types
+  --> $DIR/non-type-equality-fail.rs:33:9
+   |
+LL |     let _: Struct<{ <GenericStructImpl<N> as Trait>::PROJECTED_A }> =
+   |            -------------------------------------------------------- expected due to this
+LL |         Struct::<{ <GenericStructImpl<N> as Trait>::PROJECTED_B }>;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ
+   |
+   = note: expected struct `Struct<<GenericStructImpl<N> as Trait>::PROJECTED_A>`
+              found struct `Struct<<GenericStructImpl<N> as Trait>::PROJECTED_B>`
+
+error[E0308]: mismatched types
+  --> $DIR/non-type-equality-fail.rs:38:41
+   |
+LL |     let _: Struct<{ T::PROJECTED_A }> = Struct::<{ T::PROJECTED_B }>;
+   |            --------------------------   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ
+   |            |
+   |            expected due to this
+   |
+   = note: expected struct `Struct<<T as Trait>::PROJECTED_A>`
+              found struct `Struct<<T as Trait>::PROJECTED_B>`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/gca/non-type-equality-fail.old.stderr b/tests/ui/const-generics/gca/non-type-equality-fail.old.stderr
diff --git a/tests/ui/const-generics/gca/non-type-equality-fail.rs b/tests/ui/const-generics/gca/non-type-equality-fail.rs
diff --git a/tests/ui/const-generics/gca/non-type-equality-ok.rs b/tests/ui/const-generics/gca/non-type-equality-ok.rs
diff --git a/tests/ui/const-generics/gca/path-to-non-type-const.rs b/tests/ui/const-generics/gca/path-to-non-type-const.rs
diff --git a/tests/ui/const-generics/gca/path-to-non-type-inherent-associated-const.next.stderr b/tests/ui/const-generics/gca/path-to-non-type-inherent-associated-const.next.stderr
diff --git a/tests/ui/const-generics/gca/path-to-non-type-inherent-associated-const.old.stderr b/tests/ui/const-generics/gca/path-to-non-type-inherent-associated-const.old.stderr
diff --git a/tests/ui/const-generics/gca/path-to-non-type-inherent-associated-const.rs b/tests/ui/const-generics/gca/path-to-non-type-inherent-associated-const.rs

Original file line number	Diff line number	Diff line change
`@@ -177,6 +177,9 @@ impl<'tcx> Interner for TyCtxt<'tcx> {`
`177`	`177`	`fn type_of_opaque_hir_typeck(self, def_id: LocalDefId) -> ty::EarlyBinder<'tcx, Ty<'tcx>> {`
`178`	`178`	`self.type_of_opaque_hir_typeck(def_id)`
`179`	`179`	`}`
	`180`	`+ fn is_type_const(self, def_id: DefId) -> bool {`
	`181`	`+ self.is_type_const(def_id)`
	`182`	`+ }`
`180`	`183`	`fn const_of_item(self, def_id: DefId) -> ty::EarlyBinder<'tcx, Const<'tcx>> {`
`181`	`184`	`self.const_of_item(def_id)`
`182`	`185`	`}`