generic_const_args: allow paths to non type consts

Author: khyperia

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -3031,7 +3031,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(

compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs

@@ -14,13 +14,8 @@ 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,
-            ),
-        ) {
+        let uv = goal.predicate.alias.expect_ct(self.cx());
+        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 {

compiler/rustc_next_trait_solver/src/solve/normalizes_to/free_alias.rs

@@ -29,10 +29,24 @@ where
                 .map(|pred| goal.with(cx, pred)),
         );
 
-        let actual = if free_alias.kind(cx).is_type() {
-            cx.type_of(free_alias.def_id).instantiate(cx, free_alias.args).into()
-        } else {
-            cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args).into()
+        let actual = match free_alias.kind(cx) {
+            ty::AliasTermKind::FreeTy => {
+                cx.type_of(free_alias.def_id).instantiate(cx, free_alias.args).into()
+            }
+            ty::AliasTermKind::FreeConst { is_type_const: true } => {
+                cx.const_of_item(free_alias.def_id).instantiate(cx, free_alias.args).into()
+            }
+            ty::AliasTermKind::FreeConst { is_type_const: false } => {
+                if let Some(normalized_const) =
+                    self.evaluate_const(goal.param_env, free_alias.expect_ct(cx))
+                {
+                    normalized_const.into()
+                } else {
+                    return self
+                        .evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS);
+                }
+            }
+            kind => panic!("expected free alias, found {kind:?}"),
         };
 
         self.instantiate_normalizes_to_term(goal, actual);

compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs

@@ -51,10 +51,23 @@ where
                 .map(|pred| goal.with(cx, pred)),
         );
 
-        let normalized = if inherent.kind(cx).is_type() {
-            cx.type_of(inherent.def_id).instantiate(cx, inherent_args).into()
-        } else {
-            cx.const_of_item(inherent.def_id).instantiate(cx, inherent_args).into()
+        let normalized = match inherent.kind(cx) {
+            ty::AliasTermKind::InherentTy => {
+                cx.type_of(inherent.def_id).instantiate(cx, inherent_args).into()
+            }
+            ty::AliasTermKind::InherentConst { is_type_const: true } => {
+                cx.const_of_item(inherent.def_id).instantiate(cx, inherent_args).into()
+            }
+            ty::AliasTermKind::InherentConst { is_type_const: false } => {
+                // 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);
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)

compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs

@@ -380,15 +380,28 @@ where
             // Finally we construct the actual value of the associated type.
             let term = match goal.predicate.alias.kind(cx) {
                 ty::AliasTermKind::ProjectionTy => {
-                    cx.type_of(target_item_def_id).map_bound(|ty| ty.into())
+                    cx.type_of(target_item_def_id).instantiate(cx, target_args).into()
                 }
-                ty::AliasTermKind::ProjectionConst { .. } => {
-                    cx.const_of_item(target_item_def_id).map_bound(|ct| ct.into())
+                ty::AliasTermKind::ProjectionConst { is_type_const: true } => {
+                    cx.const_of_item(target_item_def_id).instantiate(cx, target_args).into()
+                }
+                ty::AliasTermKind::ProjectionConst { is_type_const: false } => {
+                    let uv = ty::UnevaluatedConst::new(
+                        target_item_def_id.try_into().unwrap(),
+                        target_args,
+                    );
+                    if let Some(eval) = ecx.evaluate_const(goal.param_env, uv) {
+                        eval.into()
+                    } else {
+                        return ecx.evaluate_added_goals_and_make_canonical_response(
+                            Certainty::AMBIGUOUS,
+                        );
+                    }
                 }
                 kind => panic!("expected projection, found {kind:?}"),
             };
 
-            ecx.instantiate_normalizes_to_term(goal, term.instantiate(cx, target_args));
+            ecx.instantiate_normalizes_to_term(goal, term);
             ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         })
     }

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -331,15 +331,24 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
             ),
         );
         self.depth += 1;
-        let res = if free.kind(infcx.tcx).is_type() {
-            infcx.tcx.type_of(free.def_id).instantiate(infcx.tcx, free.args).fold_with(self).into()
-        } else {
-            infcx
+        let res = match free.kind(infcx.tcx) {
+            ty::AliasTermKind::FreeTy => infcx
+                .tcx
+                .type_of(free.def_id)
+                .instantiate(infcx.tcx, free.args)
+                .fold_with(self)
+                .into(),
+            ty::AliasTermKind::FreeConst { is_type_const: true } => infcx
                 .tcx
                 .const_of_item(free.def_id)
                 .instantiate(infcx.tcx, free.args)
                 .fold_with(self)
-                .into()
+                .into(),
+            ty::AliasTermKind::FreeConst { is_type_const: false } => {
+                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;
         res

compiler/rustc_trait_selection/src/traits/project.rs

@@ -545,10 +545,22 @@ pub fn normalize_inherent_projection<'a, 'b, 'tcx>(
         ));
     }
 
-    let term: Term<'tcx> = if alias_term.kind(tcx).is_type() {
-        tcx.type_of(alias_term.def_id).instantiate(tcx, args).into()
-    } else {
-        tcx.const_of_item(alias_term.def_id).instantiate(tcx, args).into()
+    let term: Term<'tcx> = match alias_term.kind(tcx) {
+        ty::AliasTermKind::InherentTy => {
+            tcx.type_of(alias_term.def_id).instantiate(tcx, args).into()
+        }
+        ty::AliasTermKind::InherentConst { is_type_const: true } => {
+            tcx.const_of_item(alias_term.def_id).instantiate(tcx, args).into()
+        }
+        ty::AliasTermKind::InherentConst { is_type_const: false } => {
+            // 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:?}"),
     };
 
     let mut term = selcx.infcx.resolve_vars_if_possible(term);
@@ -2046,12 +2058,6 @@ fn confirm_impl_candidate<'cx, 'tcx>(
     let args = obligation.predicate.args.rebase_onto(tcx, trait_def_id, args);
     let args = translate_args(selcx.infcx, param_env, impl_def_id, args, assoc_term.defining_node);
 
-    let term = if obligation.predicate.kind(tcx).is_type() {
-        tcx.type_of(assoc_term.item.def_id).map_bound(|ty| ty.into())
-    } else {
-        tcx.const_of_item(assoc_term.item.def_id).map_bound(|ct| ct.into())
-    };
-
     let progress = if !tcx.check_args_compatible(assoc_term.item.def_id, args) {
         let msg = "impl item and trait item have different parameters";
         let span = obligation.cause.span;
@@ -2063,7 +2069,23 @@ fn confirm_impl_candidate<'cx, 'tcx>(
         Progress { term: err, obligations: nested }
     } else {
         assoc_term_own_obligations(selcx, obligation, &mut nested);
-        Progress { term: term.instantiate(tcx, args), obligations: nested }
+
+        let term = match obligation.predicate.kind(tcx) {
+            ty::AliasTermKind::ProjectionTy => {
+                tcx.type_of(assoc_term.item.def_id).instantiate(tcx, args).into()
+            }
+            ty::AliasTermKind::ProjectionConst { is_type_const: true } => {
+                tcx.const_of_item(assoc_term.item.def_id).instantiate(tcx, args).into()
+            }
+            ty::AliasTermKind::ProjectionConst { is_type_const: false } => {
+                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()
+            }
+            kind => panic!("expected projection alias, found {kind:?}"),
+        };
+
+        Progress { term, obligations: nested }
     };
     Ok(Projected::Progress(progress))
 }

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -1059,7 +1059,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),
                         ));

compiler/rustc_type_ir/src/predicate.rs

@@ -529,15 +529,17 @@ impl AliasTermKind {
     pub fn descr(self) -> &'static str {
         match self {
             AliasTermKind::ProjectionTy => "associated type",
-            AliasTermKind::ProjectionConst { is_type_const: true } => "associated const",
-            AliasTermKind::ProjectionConst { is_type_const: false } => "associated const",
+            AliasTermKind::ProjectionConst { is_type_const: true } => "associated constant",
+            AliasTermKind::ProjectionConst { is_type_const: false } => "associated type constant",
             AliasTermKind::InherentTy => "inherent associated type",
-            AliasTermKind::InherentConst { is_type_const: true } => "inherent associated const",
-            AliasTermKind::InherentConst { is_type_const: false } => "inherent associated const",
+            AliasTermKind::InherentConst { is_type_const: true } => {
+                "inherent associated type constant"
+            }
+            AliasTermKind::InherentConst { is_type_const: false } => "inherent associated constant",
             AliasTermKind::OpaqueTy => "opaque type",
             AliasTermKind::FreeTy => "type alias",
-            AliasTermKind::FreeConst { is_type_const: true } => "unevaluated constant",
-            AliasTermKind::FreeConst { is_type_const: false } => "unevaluated constant",
+            AliasTermKind::FreeConst { is_type_const: true } => "free type constant",
+            AliasTermKind::FreeConst { is_type_const: false } => "free constant",
             AliasTermKind::UnevaluatedConst => "unevaluated constant",
         }
     }
@@ -642,6 +644,22 @@ impl<I: Interner> AliasTerm<I> {
         ty::AliasTy { kind, args: self.args, _use_alias_ty_new_instead: () }
     }
 
+    pub fn expect_ct(self, interner: I) -> ty::UnevaluatedConst<I> {
+        match self.kind(interner) {
+            AliasTermKind::InherentConst { .. }
+            | AliasTermKind::FreeConst { .. }
+            | AliasTermKind::UnevaluatedConst
+            | AliasTermKind::ProjectionConst { .. } => {}
+            kind @ (AliasTermKind::ProjectionTy
+            | AliasTermKind::InherentTy
+            | AliasTermKind::OpaqueTy
+            | AliasTermKind::FreeTy) => {
+                panic!("Cannot turn `{}` into `UnevaluatedConst`", kind.descr())
+            }
+        }
+        ty::UnevaluatedConst { def: self.def_id.try_into().unwrap(), args: self.args }
+    }
+
     pub fn kind(self, interner: I) -> AliasTermKind {
         interner.alias_term_kind(self)
     }

tests/ui/const-generics/gca/path-to-non-type-const.rs

@@ -0,0 +1,36 @@
+//@ check-pass
+//@ revisions: old next
+//@[next] compile-flags: -Znext-solver
+
+#![feature(min_generic_const_args)]
+#![feature(generic_const_args)]
+#![expect(incomplete_features)]
+
+trait Trait {
+    const PROJECTED: usize;
+}
+
+struct StructImpl;
+struct GenericStructImpl<const A: usize>;
+
+const FREE: usize = 1;
+
+impl Trait for StructImpl {
+    const PROJECTED: usize = 1;
+}
+
+impl<const A: usize> Trait for GenericStructImpl<A> {
+    const PROJECTED: usize = A;
+}
+
+struct Struct<const N: usize>;
+
+fn f<T: Trait>() {
+    let _ = Struct::<{ T::PROJECTED }>;
+}
+
+fn main() {
+    let _ = Struct::<FREE>;
+    let _ = Struct::<{ <StructImpl as Trait>::PROJECTED }>;
+    let _ = Struct::<{ <GenericStructImpl<2> as Trait>::PROJECTED }>;
+}