Register ConstArgHasType when normalizing free const aliases

Author: lapla-cogito

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

@@ -49,7 +49,7 @@ where
             kind => panic!("expected free alias, found {kind:?}"),
         };
 
-        self.instantiate_normalizes_to_term(goal, actual);
+        self.instantiate_normalizes_to_term_with_type_check(goal, actual);
         self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
     }
 }

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/query/normalize.rs

@@ -4,7 +4,7 @@
 
 use rustc_data_structures::sso::SsoHashMap;
 use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_infer::traits::PredicateObligations;
+use rustc_infer::traits::{Obligation, PredicateObligations};
 use rustc_macros::extension;
 pub use rustc_middle::traits::query::NormalizationResult;
 use rustc_middle::ty::{
@@ -372,6 +372,18 @@ impl<'a, 'tcx> QueryNormalizer<'a, 'tcx> {
         } else {
             result.normalized_term
         };
+        // When normalizing a 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 =
+                tcx.type_of(term.def_id()).instantiate(tcx, term.args).skip_norm_wip();
+            self.obligations.push(Obligation::new(
+                tcx,
+                self.cause.clone(),
+                self.param_env,
+                ty::ClauseKind::ConstArgHasType(ct, expected_ty),
+            ));
+        }
         // `tcx.normalize_canonicalized_projection` may normalize to a type that
         // still has unevaluated consts, so keep normalizing here if that's the case.
         // Similarly, `tcx.normalize_canonicalized_free_alias` will only unwrap one layer

compiler/rustc_traits/src/normalize_erasing_regions.rs

@@ -63,11 +63,11 @@ fn try_normalize_after_erasing_regions<'tcx, T: TypeFoldable<TyCtxt<'tcx>> + Par
 fn not_outlives_predicate(p: ty::Predicate<'_>) -> bool {
     match p.kind().skip_binder() {
         ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(..))
-        | ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(..)) => false,
+        | ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(..))
+        | ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(..)) => false,
         ty::PredicateKind::Clause(ty::ClauseKind::Trait(..))
         | ty::PredicateKind::Clause(ty::ClauseKind::Projection(..))
         | ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(..))
-        | ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(..))
         | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
         | ty::PredicateKind::NormalizesTo(..)
         | ty::PredicateKind::AliasRelate(..)

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

@@ -0,0 +1,12 @@
+//@ compile-flags: -Zvalidate-mir -Znext-solver
+
+#![feature(min_generic_const_args)]
+#![expect(incomplete_features)]
+
+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:6: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:9: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`.

…pe-const-free-value-type-mismatch.stderr …-free-value-type-mismatch.current.stderrtests/ui/const-generics/mgca/type-const-free-value-type-mismatch.stderr renamed to tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.current.stderr tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.stderr renamed to tests/ui/const-generics/mgca/type-const-free-value-type-mismatch.current.stderr

@@ -1,11 +1,11 @@
 error: the constant `"this isn't a usize"` is not of type `usize`
-  --> $DIR/type-const-free-value-type-mismatch.rs:7:1
+  --> $DIR/type-const-free-value-type-mismatch.rs:10:1
    |
 LL | type const N: usize = "this isn't a usize";
    | ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `&'static str`
 
 error[E0080]: transmuting from $BYTE-byte type to $BYTE-byte type: `&str` -> `usize`
-  --> $DIR/type-const-free-value-type-mismatch.rs:10:24
+  --> $DIR/type-const-free-value-type-mismatch.rs:13:24
    |
 LL | fn f() -> [u8; const { N }] {}
    |                        ^ evaluation of `f::{constant#0}` failed here

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:10: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:13:11
+   |
+LL | fn f() -> [u8; const { N }] {}
+   |           ^^^^^^^^^^^^^^^^^ cannot normalize `f::{constant#0}`
+
+error[E0308]: mismatched types
+  --> $DIR/type-const-free-value-type-mismatch.rs:13: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

@@ -1,13 +1,18 @@
 #![feature(min_generic_const_args)]
 #![expect(incomplete_features)]
 
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 //@ compile-flags: -Zvalidate-mir
 //@ normalize-stderr: "\d+-byte" -> "$$BYTE-byte"
 
 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 }] {}
-//~^ ERROR transmuting from
+//[current]~^ ERROR transmuting from
+//[next]~^^ ERROR type annotations needed
+//[next]~| ERROR mismatched types [E0308]
 
 fn main() {}

tests/ui/const-generics/mgca/type_const-mismatched-types.rs

@@ -5,7 +5,8 @@ type const FREE: u32 = 5_usize;
 //~^ ERROR the constant `5` is not of type `u32`
 
 type const FREE2: isize = FREE;
-//~^ ERROR the constant `5` is not of type `isize`
+//~^ ERROR the constant `5` is not of type `u32`
+//~| ERROR the constant `5` is not of type `isize`
 
 trait Tr {
     type const N: usize;