generic_const_args: allow paths to non type consts

Author: khyperia

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(

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

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,

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

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:?}"),
         };
 

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

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:?}"),
             };
 

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

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -347,13 +347,31 @@ 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 { .. } => {
+                let ct = free.to_term(infcx.tcx).expect_const();
+                match super::try_evaluate_const(infcx, ct, self.param_env) {
+                    Ok(ct) => ct,
+                    Err(
+                        super::EvaluateConstErr::EvaluationFailure(e)
+                        | super::EvaluateConstErr::InvalidConstParamTy(e),
+                    ) => ty::Const::new_error(infcx.tcx, e),
+                    Err(super::EvaluateConstErr::HasGenericsOrInfers) => {
+                        if infcx.resolve_vars_if_possible(ct).has_non_region_infer() {
+                            infcx.next_const_var(self.cause.span)
+                        } else {
+                            ct
+                        }
+                    }
+                }
+                .into()
+            }
             kind => panic!("expected free alias, found {kind:?}"),
         };
         self.depth -= 1;
@@ -376,6 +394,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;

compiler/rustc_trait_selection/src/traits/project.rs

@@ -11,6 +11,7 @@ use rustc_infer::infer::resolve::OpportunisticRegionResolver;
 use rustc_infer::traits::{ObligationCauseCode, PredicateObligations};
 use rustc_middle::traits::select::OverflowError;
 use rustc_middle::traits::{BuiltinImplSource, ImplSource, ImplSourceUserDefinedData};
+use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::fast_reject::DeepRejectCtxt;
 use rustc_middle::ty::{
     self, FieldInfo, Term, Ty, TyCtxt, TypeFoldable, TypeVisitableExt, TypingMode, Upcast,
@@ -549,9 +550,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 +626,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 +663,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 +2071,29 @@ 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) => {
+                        if selcx.infcx.resolve_vars_if_possible(uv).has_non_region_infer() {
+                            return Err(ProjectionError::TraitSelectionError(
+                                SelectionError::NotConstEvaluatable(
+                                    NotConstEvaluatable::MentionsInfer,
+                                ),
+                            ));
+                        } else {
+                            return Ok(Projected::NoProgress(obligation.predicate.to_term(tcx)));
+                        }
+                    }
+                }
             }
             kind => panic!("expected projection alias, found {kind:?}"),
         };