mGCA: Validate const literal against expected type

Author: reddevilmidzy

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -21,7 +21,7 @@ pub mod generics;
 
 use std::slice;
 
-use rustc_ast::LitKind;
+use rustc_ast::{LitFloatType, LitIntType, LitKind};
 use rustc_data_structures::assert_matches;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
@@ -31,7 +31,7 @@ use rustc_errors::{
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::{self as hir, AnonConst, GenericArg, GenericArgs, HirId, find_attr};
+use rustc_hir::{self as hir, AnonConst, GenericArg, GenericArgs, HirId, LangItem, find_attr};
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::DynCompatibilityViolation;
 use rustc_macros::{TypeFoldable, TypeVisitable};
@@ -2807,10 +2807,70 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     #[instrument(skip(self), level = "debug")]
     fn lower_const_arg_literal(&self, kind: &LitKind, ty: Ty<'tcx>, span: Span) -> Const<'tcx> {
         let tcx = self.tcx();
+        if let LitKind::Err(guar) = *kind {
+            return ty::Const::new_error(tcx, guar);
+        }
+        if !self.const_lit_matches_ty(kind, ty, false) {
+            let found = self.const_lit_description(kind);
+            let e = tcx.dcx().span_err(span, format!("expected `{}`, found `{found}`", ty));
+            return ty::Const::new_error(tcx, e);
+        }
         let input = LitToConstInput { lit: *kind, ty, neg: false };
         tcx.at(span).lit_to_const(input)
     }
 
+    fn const_lit_matches_ty(&self, kind: &LitKind, ty: Ty<'tcx>, neg: bool) -> bool {
+        let tcx = self.tcx();
+        match (*kind, ty.kind()) {
+            (LitKind::Str(..), ty::Ref(_, inner_ty, _)) if inner_ty.is_str() => true,
+            (LitKind::Str(..), ty::Str) if tcx.features().deref_patterns() => true,
+            (LitKind::ByteStr(..), ty::Ref(_, inner_ty, _))
+                if let ty::Slice(ty) | ty::Array(ty, _) = inner_ty.kind()
+                    && matches!(ty.kind(), ty::Uint(ty::UintTy::U8)) =>
+            {
+                true
+            }
+            (LitKind::ByteStr(..), ty::Slice(inner_ty) | ty::Array(inner_ty, _))
+                if tcx.features().deref_patterns()
+                    && matches!(inner_ty.kind(), ty::Uint(ty::UintTy::U8)) =>
+            {
+                true
+            }
+            (LitKind::Byte(..), ty::Uint(ty::UintTy::U8)) => true,
+            (LitKind::CStr(..), ty::Ref(_, inner_ty, _)) if matches!(inner_ty.kind(), ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::CStr)) => {
+                true
+            }
+            (LitKind::Int(..), ty::Uint(_)) if !neg => true,
+            (LitKind::Int(..), ty::Int(_)) => true,
+            (LitKind::Bool(..), ty::Bool) => true,
+            (LitKind::Float(..), ty::Float(_)) => true,
+            (LitKind::Char(..), ty::Char) => true,
+            (LitKind::Err(..), _) => true,
+            _ => false,
+        }
+    }
+
+    fn const_lit_description(&self, kind: &LitKind) -> &'static str {
+        match *kind {
+            LitKind::Str(..) => "&str",
+            LitKind::ByteStr(..) => "&[u8]",
+            LitKind::CStr(..) => "&CStr",
+            LitKind::Byte(..) => "u8",
+            LitKind::Int(_, suffix) => match suffix {
+                LitIntType::Signed(int_ty) => int_ty.name_str(),
+                LitIntType::Unsigned(uint_ty) => uint_ty.name_str(),
+                LitIntType::Unsuffixed => "{integer}",
+            },
+            LitKind::Float(_, suffix) => match suffix {
+                LitFloatType::Suffixed(float_ty) => float_ty.name_str(),
+                LitFloatType::Unsuffixed => "{float}",
+            },
+            LitKind::Bool(..) => "bool",
+            LitKind::Char(..) => "char",
+            LitKind::Err(..) => "erroneous literal",
+        }
+    }
+
     #[instrument(skip(self), level = "debug")]
     fn try_lower_anon_const_lit(
         &self,

tests/ui/const-generics/mgca/generic_const_type_mismatch.rs

@@ -0,0 +1,20 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/150983>
+#![expect(incomplete_features)]
+#![feature(
+    generic_const_items,
+    generic_const_parameter_types,
+    min_generic_const_args,
+    unsized_const_params
+)]
+use std::marker::ConstParamTy_;
+
+struct Foo<T> {
+    field: T,
+}
+
+#[type_const]
+const WRAP<T : ConstParamTy_> : T = {
+    Foo::<T>{field : 1} //~ ERROR: expected `T`, found `{integer}`
+};
+
+fn main() {}

tests/ui/const-generics/mgca/generic_const_type_mismatch.stderr

@@ -0,0 +1,8 @@
+error: expected `T`, found `{integer}`
+  --> $DIR/generic_const_type_mismatch.rs:17:22
+   |
+LL |     Foo::<T>{field : 1}
+   |                      ^
+
+error: aborting due to 1 previous error
+

tests/ui/const-generics/mgca/tuple_expr_type_mismatch.rs

@@ -0,0 +1,22 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/151625>
+#![expect(incomplete_features)]
+#![feature(
+    adt_const_params,
+    min_generic_const_args,
+    unsized_const_params
+)]
+fn foo<const X: (bool, i32)>() {}
+fn bar<const Y: ([u8; 2], i32)>() {}
+fn qux<const Z: (char, i32)>() {}
+
+fn main() {
+    foo::<{ (1, true) }>();
+    //~^ ERROR: expected `bool`, found `{integer}`
+    //~| ERROR: expected `i32`, found `bool`
+    bar::<{ (1_u32, [1, 2]) }>();
+    //~^ ERROR: expected `[u8; 2]`, found `u32`
+    //~| ERROR: expected `i32`, found const array
+    qux::<{ (1i32, 'a') }>();
+    //~^ ERROR: expected `char`, found `i32`
+    //~| ERROR: expected `i32`, found `char`
+}

tests/ui/const-generics/mgca/tuple_expr_type_mismatch.stderr

@@ -0,0 +1,38 @@
+error: expected `bool`, found `{integer}`
+  --> $DIR/tuple_expr_type_mismatch.rs:13:14
+   |
+LL |     foo::<{ (1, true) }>();
+   |              ^
+
+error: expected `i32`, found `bool`
+  --> $DIR/tuple_expr_type_mismatch.rs:13:17
+   |
+LL |     foo::<{ (1, true) }>();
+   |                 ^^^^
+
+error: expected `[u8; 2]`, found `u32`
+  --> $DIR/tuple_expr_type_mismatch.rs:16:14
+   |
+LL |     bar::<{ (1_u32, [1, 2]) }>();
+   |              ^^^^^
+
+error: expected `i32`, found const array
+  --> $DIR/tuple_expr_type_mismatch.rs:16:21
+   |
+LL |     bar::<{ (1_u32, [1, 2]) }>();
+   |                     ^^^^^^
+
+error: expected `char`, found `i32`
+  --> $DIR/tuple_expr_type_mismatch.rs:19:14
+   |
+LL |     qux::<{ (1i32, 'a') }>();
+   |              ^^^^
+
+error: expected `i32`, found `char`
+  --> $DIR/tuple_expr_type_mismatch.rs:19:20
+   |
+LL |     qux::<{ (1i32, 'a') }>();
+   |                    ^^^
+
+error: aborting due to 6 previous errors
+