Extract shared helper for registering ConstArgHasType during const projection normalization

Author: lapla-cogito

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

@@ -5,7 +5,6 @@
 //! 2. equate the self type, and
 //! 3. instantiate and register where clauses.
 
-use rustc_type_ir::inherent::*;
 use rustc_type_ir::{self as ty, Interner, Unnormalized};
 
 use crate::delegate::SolverDelegate;
@@ -59,15 +58,7 @@ where
             cx.const_of_item(inherent.def_id).instantiate(cx, inherent_args).skip_norm_wip().into()
         };
 
-        if let Some(ct) = normalized.as_const() {
-            let expected_ty = cx.type_of(inherent.def_id).instantiate(cx, inherent_args);
-            self.add_goal(
-                GoalSource::Misc,
-                goal.with(cx, ty::ClauseKind::ConstArgHasType(ct, expected_ty)),
-            );
-        }
-
-        self.instantiate_normalizes_to_term(goal, normalized);
+        self.instantiate_normalizes_to_term_with_type_check(goal, normalized);
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }

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

@@ -110,6 +110,27 @@ where
             .expect("expected goal term to be fully unconstrained");
     }
 
+    /// Like `instantiate_normalizes_to_term`, but also registers a
+    /// `ConstArgHasType` goal when the term is a const. This ensures that
+    /// the const value's type matches the type of the alias it was
+    /// normalized from, preventing ICEs from type mismatches.
+    pub fn instantiate_normalizes_to_term_with_type_check(
+        &mut self,
+        goal: Goal<I, NormalizesTo<I>>,
+        term: I::Term,
+    ) {
+        if let Some(ct) = term.as_const() {
+            let cx = self.cx();
+            let alias = goal.predicate.alias;
+            let expected_ty = cx.type_of(alias.def_id).instantiate(cx, alias.args).skip_norm_wip();
+            self.add_goal(
+                GoalSource::Misc,
+                goal.with(cx, ty::ClauseKind::ConstArgHasType(ct, expected_ty)),
+            );
+        }
+        self.instantiate_normalizes_to_term(goal, term);
+    }
+
     /// Unlike `instantiate_normalizes_to_term` this instantiates the expected term
     /// with a rigid alias. Using this is pretty much always wrong.
     pub fn structurally_instantiate_normalizes_to_term(
@@ -393,16 +414,10 @@ where
                 kind => panic!("expected projection, found {kind:?}"),
             };
 
-            let instantiated_term: I::Term = term.instantiate(cx, target_args);
-            if let Some(ct) = instantiated_term.as_const() {
-                let expected_ty = cx.type_of(target_item_def_id).instantiate(cx, target_args);
-                ecx.add_goal(
-                    GoalSource::Misc,
-                    goal.with(cx, ty::ClauseKind::ConstArgHasType(ct, expected_ty)),
-                );
-            }
-
-            ecx.instantiate_normalizes_to_term(goal, instantiated_term.skip_norm_wip());
+            ecx.instantiate_normalizes_to_term_with_type_check(
+                goal,
+                term.instantiate(cx, target_args).skip_norm_wip(),
+            );
             ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         })
     }

compiler/rustc_trait_selection/src/traits/project.rs

@@ -5,6 +5,7 @@ use std::ops::ControlFlow;
 use rustc_data_structures::sso::SsoHashSet;
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::ErrorGuaranteed;
+use rustc_hir::def_id::DefId;
 use rustc_hir::lang_items::LangItem;
 use rustc_infer::infer::DefineOpaqueTypes;
 use rustc_infer::infer::resolve::OpportunisticRegionResolver;
@@ -482,6 +483,30 @@ fn normalize_to_error<'a, 'tcx>(
     Normalized { value: new_value, obligations }
 }
 
+/// When normalizing a const alias, register a `ConstArgHasType` obligation
+/// to ensure the const value's type matches the declared type.
+fn push_const_arg_has_type_obligation<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    obligations: &mut PredicateObligations<'tcx>,
+    cause: &ObligationCause<'tcx>,
+    depth: usize,
+    param_env: ty::ParamEnv<'tcx>,
+    term: Term<'tcx>,
+    def_id: DefId,
+    args: ty::GenericArgsRef<'tcx>,
+) {
+    if let Some(ct) = term.as_const() {
+        let expected_ty = tcx.type_of(def_id).instantiate(tcx, args).skip_norm_wip();
+        obligations.push(Obligation::with_depth(
+            tcx,
+            cause.clone(),
+            depth,
+            param_env,
+            ty::ClauseKind::ConstArgHasType(ct, expected_ty),
+        ));
+    }
+}
+
 /// Confirm and normalize the given inherent projection.
 // FIXME(mgca): While this supports constants, it is only used for types by default right now
 #[instrument(level = "debug", skip(selcx, param_env, cause, obligations))]
@@ -549,16 +574,16 @@ pub fn normalize_inherent_projection<'a, 'b, 'tcx>(
         tcx.const_of_item(alias_term.def_id).instantiate(tcx, args).skip_norm_wip().into()
     };
 
-    if let Some(ct) = term.as_const() {
-        let expected_ty = tcx.type_of(alias_term.def_id).instantiate(tcx, args);
-        obligations.push(Obligation::with_depth(
-            tcx,
-            cause.clone(),
-            depth + 1,
-            param_env,
-            ty::ClauseKind::ConstArgHasType(ct, expected_ty),
-        ));
-    }
+    push_const_arg_has_type_obligation(
+        tcx,
+        obligations,
+        &cause,
+        depth + 1,
+        param_env,
+        term,
+        alias_term.def_id,
+        args,
+    );
 
     let mut term = selcx.infcx.resolve_vars_if_possible(term);
     if term.has_aliases() {
@@ -2067,18 +2092,18 @@ fn confirm_impl_candidate<'cx, 'tcx>(
         Progress { term: err, obligations: nested }
     } else {
         assoc_term_own_obligations(selcx, obligation, &mut nested);
-        let instantiated_term: Term<'tcx> = term.instantiate(tcx, args);
-        if let Some(ct) = instantiated_term.as_const() {
-            let expected_ty = tcx.type_of(assoc_term.item.def_id).instantiate(tcx, args);
-            nested.push(Obligation::with_depth(
-                tcx,
-                obligation.cause.clone(),
-                obligation.recursion_depth + 1,
-                obligation.param_env,
-                ty::ClauseKind::ConstArgHasType(ct, expected_ty),
-            ));
-        }
-        Progress { term: instantiated_term.skip_norm_wip(), obligations: nested }
+        let instantiated_term: Term<'tcx> = term.instantiate(tcx, args).skip_norm_wip();
+        push_const_arg_has_type_obligation(
+            tcx,
+            &mut nested,
+            &obligation.cause,
+            obligation.recursion_depth + 1,
+            obligation.param_env,
+            instantiated_term,
+            assoc_term.item.def_id,
+            args,
+        );
+        Progress { term: instantiated_term, obligations: nested }
     };
     Ok(Projected::Progress(progress))
 }