Unrolled build for #154853

Rollup merge of #154853 - lapla-cogito:normlize_projecttion_const, r=BoxyUwU

mgca: Register `ConstArgHasType` when normalizing projection consts

Fixes #152962
Fixes #154748
Fixes #154750

When running CTFE on a MIR body, normalizing a type const within that body can change the type of the resulting value, causing the MIR to become ill-formed. Since no prior error has been reported at that point, MIR validation fires a `span_bug!`. The existing `ConstArgHasType` check in `wfcheck::check_type_const` does catch this at the definition site, but due to query evaluation ordering, the normalization path can reach MIR validation before that check has run.

Fix this by registering a `ConstArgHasType(ct, expected_ty)` obligation/goal when normalizing projection consts (both trait and inherent), in both the old and new trait solvers. This ensures the type mismatch is reported as an error during normalization itself, which taints the MIR before validation runs.

The first commit fixes the original case reported in the issue. The second commit fixes a different ICE pattern reported within the issue (see #152962 (comment)).

r? BoxyUwU

Author: rust-timer

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

@@ -54,7 +54,7 @@ where
                 .map(|pred| goal.with(cx, pred)),
         );
 
-        let normalized = match inherent.kind {
+        let normalized: I::Term = match inherent.kind {
             ty::AliasTermKind::InherentTy { def_id } => {
                 cx.type_of(def_id.into()).instantiate(cx, inherent_args).skip_norm_wip().into()
             }
@@ -74,6 +74,7 @@ where
             }
             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

@@ -121,11 +121,42 @@ where
     /// We know `term` to always be a fully unconstrained inference variable, so
     /// `eq` should never fail here. However, in case `term` contains aliases, we
     /// emit nested `AliasRelate` goals to structurally normalize the alias.
+    ///
+    /// Additionally, when `term` is a const, this registers a `ConstArgHasType`
+    /// goal to ensure that the const value's type matches the declared type of
+    /// the alias it was normalized from.
+    ///
+    /// You may reasonably wonder: shouldn't `wfcheck::check_type_const` already
+    /// catch any such type mismatch at the definition site, so that the
+    /// definition is tainted and we never even attempt to normalize a reference
+    /// to it? In principle that's exactly what should happen. However, we cannot
+    /// simply force the defining item's wfcheck to run before all uses are
+    /// normalized: wfcheck itself may depend on typeck, trait solving, and
+    /// normalization, so enforcing such a strict ordering would easily create
+    /// query cycles.
+    ///
+    /// However, when CTFE runs on a MIR body, normalizing a type const within
+    /// that body can change the type of the resulting value, causing the MIR
+    /// to become ill-formed. If `check_type_const` for that alias has not yet
+    /// reported its error, no prior error has been recorded and MIR validation
+    /// fires a `span_bug!`. Registering the obligation here ensures the type
+    /// mismatch is reported during normalization itself, tainting the MIR
+    /// before validation runs.
     pub fn instantiate_normalizes_to_term(
         &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.eq(goal.param_env, goal.predicate.term, term)
             .expect("expected goal term to be fully unconstrained");
     }

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -339,7 +339,7 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
                 }),
         );
         self.depth += 1;
-        let res = if free.kind.is_type() {
+        let res: ty::Term<'tcx> = if free.kind.is_type() {
             infcx
                 .tcx
                 .type_of(free.def_id())
@@ -356,6 +356,19 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> {
                 .fold_with(self)
                 .into()
         };
+        // When normalizing a free const alias, register a `ConstArgHasType`
+        // obligation to ensure the const value's type matches the declared type.
+        if let Some(ct) = res.as_const() {
+            let expected_ty =
+                infcx.tcx.type_of(free.def_id()).instantiate(infcx.tcx, free.args).skip_norm_wip();
+            self.obligations.push(Obligation::with_depth(
+                infcx.tcx,
+                self.cause.clone(),
+                self.depth,
+                self.param_env,
+                ty::ClauseKind::ConstArgHasType(ct, expected_ty),
+            ));
+        }
         self.depth -= 1;
         res
     }

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;
@@ -487,6 +488,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))]
@@ -554,6 +579,17 @@ pub fn normalize_inherent_projection<'a, 'b, 'tcx>(
         tcx.const_of_item(alias_term.def_id()).instantiate(tcx, args).skip_norm_wip().into()
     };
 
+    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() {
         term =
@@ -2049,7 +2085,18 @@ 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).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))
 }

compiler/rustc_traits/src/normalize_projection_ty.rs

@@ -2,7 +2,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::infer::canonical::{Canonical, QueryResponse};
 use rustc_infer::traits::PredicateObligations;
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{ParamEnvAnd, TyCtxt};
+use rustc_middle::ty::{self, ParamEnvAnd, TyCtxt};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::InferCtxtBuilderExt;
 use rustc_trait_selection::traits::query::normalize::NormalizationResult;
@@ -19,6 +19,25 @@ pub(crate) fn provide(p: &mut Providers) {
     };
 }
 
+/// If `normalized_term` is a const, returns a `ConstArgHasType` obligation
+/// to verify that the const value's type matches the alias's declared type.
+/// Returns `None` if the term is a type rather than a const.
+fn const_arg_has_type_obligation<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    normalized_term: ty::Term<'tcx>,
+    goal: ty::AliasTerm<'tcx>,
+) -> Option<traits::PredicateObligation<'tcx>> {
+    let ct = normalized_term.as_const()?;
+    let expected_ty = tcx.type_of(goal.def_id()).instantiate(tcx, goal.args).skip_norm_wip();
+    Some(traits::Obligation::new(
+        tcx,
+        ObligationCause::dummy(),
+        param_env,
+        ty::ClauseKind::ConstArgHasType(ct, expected_ty),
+    ))
+}
+
 fn normalize_canonicalized_projection<'tcx>(
     tcx: TyCtxt<'tcx>,
     goal: CanonicalAliasGoal<'tcx>,
@@ -40,6 +59,12 @@ fn normalize_canonicalized_projection<'tcx>(
                 0,
                 &mut obligations,
             );
+            obligations.extend(const_arg_has_type_obligation(
+                tcx,
+                param_env,
+                normalized_term,
+                goal.into(),
+            ));
             ocx.register_obligations(obligations);
             // #112047: With projections and opaques, we are able to create opaques that
             // are recursive (given some generic parameters of the opaque's type variables).
@@ -86,11 +111,17 @@ fn normalize_canonicalized_free_alias<'tcx>(
                 },
             );
             ocx.register_obligations(obligations);
-            let normalized_term = if goal.kind.is_type() {
+            let normalized_term: ty::Term<'tcx> = if goal.kind.is_type() {
                 tcx.type_of(goal.def_id()).instantiate(tcx, goal.args).skip_norm_wip().into()
             } else {
                 tcx.const_of_item(goal.def_id()).instantiate(tcx, goal.args).skip_norm_wip().into()
             };
+            ocx.register_obligations(const_arg_has_type_obligation(
+                tcx,
+                param_env,
+                normalized_term,
+                goal.into(),
+            ));
             Ok(NormalizationResult { normalized_term })
         },
     )
@@ -116,6 +147,12 @@ fn normalize_canonicalized_inherent_projection<'tcx>(
                 0,
                 &mut obligations,
             );
+            obligations.extend(const_arg_has_type_obligation(
+                tcx,
+                param_env,
+                normalized_term,
+                goal.into(),
+            ));
             ocx.register_obligations(obligations);
 
             Ok(NormalizationResult { normalized_term })

tests/ui/const-generics/mgca/type-const-free-anon-const-mismatch.rs

@@ -0,0 +1,11 @@
+//@ compile-flags: -Zvalidate-mir -Znext-solver
+
+#![feature(min_generic_const_args)]
+
+type const X: usize = const { N };
+//~^ ERROR type annotations needed
+
+type const N: usize = "this isn't a usize";
+//~^ ERROR the constant `"this isn't a usize"` is not of type `usize`
+
+fn main() {}

tests/ui/const-generics/mgca/type-const-free-anon-const-mismatch.stderr

@@ -0,0 +1,15 @@
+error[E0284]: type annotations needed: cannot normalize `X::{constant#0}`
+  --> $DIR/type-const-free-anon-const-mismatch.rs:5:1
+   |
+LL | type const X: usize = const { N };
+   | ^^^^^^^^^^^^^^^^^^^ cannot normalize `X::{constant#0}`
+
+error: the constant `"this isn't a usize"` is not of type `usize`
+  --> $DIR/type-const-free-anon-const-mismatch.rs:8:1
+   |
+LL | type const N: usize = "this isn't a usize";
+   | ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `&'static str`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0284`.

tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.current.stderr

@@ -0,0 +1,17 @@
+error: the constant `"this isn't a usize"` is not of type `usize`
+  --> $DIR/type-const-free-value-type-mismatch.rs:8:1
+   |
+LL | type const N: usize = "this isn't a usize";
+   | ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `&'static str`
+
+error[E0308]: mismatched types
+  --> $DIR/type-const-free-value-type-mismatch.rs:11:11
+   |
+LL | fn f() -> [u8; const { N }] {}
+   |    -      ^^^^^^^^^^^^^^^^^ expected `[u8; const { N }]`, found `()`
+   |    |
+   |    implicitly returns `()` as its body has no tail or `return` expression
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.

tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.next.stderr

@@ -0,0 +1,24 @@
+error: the constant `"this isn't a usize"` is not of type `usize`
+  --> $DIR/type-const-free-value-type-mismatch.rs:8:1
+   |
+LL | type const N: usize = "this isn't a usize";
+   | ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `&'static str`
+
+error[E0284]: type annotations needed: cannot normalize `f::{constant#0}`
+  --> $DIR/type-const-free-value-type-mismatch.rs:11:11
+   |
+LL | fn f() -> [u8; const { N }] {}
+   |           ^^^^^^^^^^^^^^^^^ cannot normalize `f::{constant#0}`
+
+error[E0308]: mismatched types
+  --> $DIR/type-const-free-value-type-mismatch.rs:11:11
+   |
+LL | fn f() -> [u8; const { N }] {}
+   |    -      ^^^^^^^^^^^^^^^^^ expected `[u8; _]`, found `()`
+   |    |
+   |    implicitly returns `()` as its body has no tail or `return` expression
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0284, E0308.
+For more information about an error, try `rustc --explain E0284`.

tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.rs

@@ -0,0 +1,16 @@
+#![feature(min_generic_const_args)]
+
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@ compile-flags: -Zvalidate-mir
+
+type const N: usize = "this isn't a usize";
+//~^ ERROR the constant `"this isn't a usize"` is not of type `usize`
+
+fn f() -> [u8; const { N }] {}
+//[current]~^ ERROR mismatched types [E0308]
+//[next]~^^ ERROR type annotations needed
+//[next]~| ERROR mismatched types [E0308]
+
+fn main() {}