mGCA: Validate const literal against expected type

reddevilmidzy · reddevilmidzy · commit cd5b323073d4 · 2026-02-07T10:09:08.000Z
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2798,8 +2798,17 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         span: Span,
     ) -> Const<'tcx> {
         let tcx = self.tcx();
-        let input = LitToConstInput { lit: *kind, ty, neg };
-        tcx.at(span).lit_to_const(input)
+        if let LitKind::Err(guar) = *kind {
+            return ty::Const::new_error(tcx, guar);
+        }
+        let input = LitToConstInput { lit: *kind, ty, neg: false };
+        match tcx.at(span).lit_to_const(input) {
+            Some(value) => ty::Const::new_value(tcx, value.valtree, value.ty),
+            None => {
+                let e = tcx.dcx().span_err(span, "type annotations needed for the literal");
+                ty::Const::new_error(tcx, e)
+            }
+        }
     }
 
     #[instrument(skip(self), level = "debug")]
@@ -2832,7 +2841,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             // Allow the `ty` to be an alias type, though we cannot handle it here, we just go through
             // the more expensive anon const code path.
             .filter(|l| !l.ty.has_aliases())
-            .map(|l| tcx.at(expr.span).lit_to_const(l))
+            .and_then(|l| {
+                tcx.at(expr.span)
+                    .lit_to_const(l)
+                    .map(|value| ty::Const::new_value(tcx, value.valtree, value.ty))
+            })
     }
 
     fn require_type_const_attribute(
diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs
@@ -1412,7 +1412,7 @@ rustc_queries! {
     // FIXME get rid of this with valtrees
     query lit_to_const(
         key: LitToConstInput<'tcx>
-    ) -> ty::Const<'tcx> {
+    ) -> Option<ty::Value<'tcx>> {
         desc { "converting literal to const" }
     }
 
diff --git a/compiler/rustc_middle/src/query/erase.rs b/compiler/rustc_middle/src/query/erase.rs
@@ -256,6 +256,10 @@ impl Erasable for Option<ty::EarlyBinder<'_, Ty<'_>>> {
     type Storage = [u8; size_of::<Option<ty::EarlyBinder<'static, Ty<'static>>>>()];
 }
 
+impl Erasable for Option<ty::Value<'_>> {
+    type Storage = [u8; size_of::<Option<ty::Value<'static>>>()];
+}
+
 impl Erasable for rustc_hir::MaybeOwner<'_> {
     type Storage = [u8; size_of::<rustc_hir::MaybeOwner<'static>>()];
 }
diff --git a/compiler/rustc_mir_build/src/thir/constant.rs b/compiler/rustc_mir_build/src/thir/constant.rs
@@ -1,7 +1,6 @@
 use rustc_abi::Size;
 use rustc_ast::{self as ast, UintTy};
 use rustc_hir::LangItem;
-use rustc_middle::bug;
 use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::ty::{self, ScalarInt, TyCtxt, TypeVisitableExt as _};
 use tracing::trace;
@@ -11,11 +10,11 @@ use crate::builder::parse_float_into_scalar;
 pub(crate) fn lit_to_const<'tcx>(
     tcx: TyCtxt<'tcx>,
     lit_input: LitToConstInput<'tcx>,
-) -> ty::Const<'tcx> {
+) -> Option<ty::Value<'tcx>> {
     let LitToConstInput { lit, ty, neg } = lit_input;
 
-    if let Err(guar) = ty.error_reported() {
-        return ty::Const::new_error(tcx, guar);
+    if ty.error_reported().is_err() {
+        return None;
     }
 
     let trunc = |n, width: ty::UintTy| {
@@ -29,7 +28,6 @@ pub(crate) fn lit_to_const<'tcx>(
         trace!("trunc result: {}", result);
 
         ScalarInt::try_from_uint(result, width)
-            .unwrap_or_else(|| bug!("expected to create ScalarInt from uint {:?}", result))
     };
 
     let valtree = match (lit, ty.kind()) {
@@ -68,27 +66,25 @@ pub(crate) fn lit_to_const<'tcx>(
             ty::ValTree::from_branches(tcx, [ty::Const::new_value(tcx, bytes, *inner_ty)])
         }
         (ast::LitKind::Int(n, _), ty::Uint(ui)) if !neg => {
-            let scalar_int = trunc(n.get(), *ui);
+            let scalar_int = trunc(n.get(), *ui)?;
             ty::ValTree::from_scalar_int(tcx, scalar_int)
         }
         (ast::LitKind::Int(n, _), ty::Int(i)) => {
             // Unsigned "negation" has the same bitwise effect as signed negation,
             // which gets the result we want without additional casts.
             let scalar_int =
-                trunc(if neg { u128::wrapping_neg(n.get()) } else { n.get() }, i.to_unsigned());
+                trunc(if neg { u128::wrapping_neg(n.get()) } else { n.get() }, i.to_unsigned())?;
             ty::ValTree::from_scalar_int(tcx, scalar_int)
         }
         (ast::LitKind::Bool(b), ty::Bool) => ty::ValTree::from_scalar_int(tcx, b.into()),
         (ast::LitKind::Float(n, _), ty::Float(fty)) => {
-            let bits = parse_float_into_scalar(n, *fty, neg).unwrap_or_else(|| {
-                tcx.dcx().bug(format!("couldn't parse float literal: {:?}", lit_input.lit))
-            });
+            let bits = parse_float_into_scalar(n, *fty, neg)?;
             ty::ValTree::from_scalar_int(tcx, bits)
         }
         (ast::LitKind::Char(c), ty::Char) => ty::ValTree::from_scalar_int(tcx, c.into()),
-        (ast::LitKind::Err(guar), _) => return ty::Const::new_error(tcx, guar),
-        _ => return ty::Const::new_misc_error(tcx),
+        (ast::LitKind::Err(_), _) => return None,
+        _ => return None,
     };
 
-    ty::Const::new_value(tcx, valtree, ty)
+    Some(ty::Value { ty, valtree })
 }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -8,11 +8,12 @@ use std::cmp::Ordering;
 use std::sync::Arc;
 
 use rustc_abi::{FieldIdx, Integer};
+use rustc_ast::LitKind;
 use rustc_data_structures::assert_matches;
 use rustc_errors::codes::*;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::pat_util::EnumerateAndAdjustIterator;
-use rustc_hir::{self as hir, RangeEnd};
+use rustc_hir::{self as hir, LangItem, RangeEnd};
 use rustc_index::Idx;
 use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::thir::{
@@ -197,8 +198,6 @@ impl<'tcx> PatCtxt<'tcx> {
         expr: Option<&'tcx hir::PatExpr<'tcx>>,
         ty: Ty<'tcx>,
     ) -> Result<(), ErrorGuaranteed> {
-        use rustc_ast::ast::LitKind;
-
         let Some(expr) = expr else {
             return Ok(());
         };
@@ -696,9 +695,58 @@ impl<'tcx> PatCtxt<'tcx> {
 
                 let pat_ty = self.typeck_results.node_type(pat.hir_id);
                 let lit_input = LitToConstInput { lit: lit.node, ty: pat_ty, neg: *negated };
-                let constant = self.tcx.at(expr.span).lit_to_const(lit_input);
+                let error_const = || {
+                    if let Some(guar) = self.typeck_results.tainted_by_errors {
+                        ty::Const::new_error(self.tcx, guar)
+                    } else {
+                        ty::Const::new_error_with_message(
+                            self.tcx,
+                            expr.span,
+                            "literal does not match expected type",
+                        )
+                    }
+                };
+                let constant = if self.const_lit_matches_ty(&lit.node, pat_ty, *negated) {
+                    match self.tcx.at(expr.span).lit_to_const(lit_input) {
+                        Some(value) => ty::Const::new_value(self.tcx, value.valtree, value.ty),
+                        None => error_const(),
+                    }
+                } else {
+                    error_const()
+                };
                 self.const_to_pat(constant, pat_ty, expr.hir_id, lit.span)
             }
         }
     }
+
+    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,
+        }
+    }
 }
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
@@ -59,7 +59,10 @@ fn recurse_build<'tcx>(
         }
         &ExprKind::Literal { lit, neg } => {
             let sp = node.span;
-            tcx.at(sp).lit_to_const(LitToConstInput { lit: lit.node, ty: node.ty, neg })
+            match tcx.at(sp).lit_to_const(LitToConstInput { lit: lit.node, ty: node.ty, neg }) {
+                Some(value) => ty::Const::new_value(tcx, value.valtree, value.ty),
+                None => ty::Const::new_misc_error(tcx),
+            }
         }
         &ExprKind::NonHirLiteral { lit, user_ty: _ } => {
             let val = ty::ValTree::from_scalar_int(tcx, lit);
diff --git a/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.rs b/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.rs
@@ -8,7 +8,7 @@
 struct ConstBytes<const T: &'static [*mut u8; 3]>
 //~^ ERROR rustc_dump_predicates
 //~| NOTE Binder { value: ConstArgHasType(T/#0, &'static [*mut u8; 3_usize]), bound_vars: [] }
-//~| NOTE Binder { value: TraitPredicate(<ConstBytes<{const error}> as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+//~| NOTE Binder { value: TraitPredicate(<ConstBytes<b"AAA"> as std::marker::Sized>, polarity:Positive), bound_vars: [] }
 where
     ConstBytes<b"AAA">: Sized;
 //~^ ERROR mismatched types
diff --git a/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.stderr b/tests/ui/const-generics/adt_const_params/byte-string-u8-validation.stderr
@@ -1,12 +1,3 @@
-error: rustc_dump_predicates
-  --> $DIR/byte-string-u8-validation.rs:8:1
-   |
-LL | struct ConstBytes<const T: &'static [*mut u8; 3]>
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: Binder { value: ConstArgHasType(T/#0, &'static [*mut u8; 3_usize]), bound_vars: [] }
-   = note: Binder { value: TraitPredicate(<ConstBytes<{const error}> as std::marker::Sized>, polarity:Positive), bound_vars: [] }
-
 error[E0308]: mismatched types
   --> $DIR/byte-string-u8-validation.rs:13:16
    |
@@ -16,6 +7,15 @@ LL |     ConstBytes<b"AAA">: Sized;
    = note: expected reference `&'static [*mut u8; 3]`
               found reference `&'static [u8; 3]`
 
+error: rustc_dump_predicates
+  --> $DIR/byte-string-u8-validation.rs:8:1
+   |
+LL | struct ConstBytes<const T: &'static [*mut u8; 3]>
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: Binder { value: ConstArgHasType(T/#0, &'static [*mut u8; 3_usize]), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<ConstBytes<b"AAA"> as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/adt_const_params/mismatch-raw-ptr-in-adt.stderr b/tests/ui/const-generics/adt_const_params/mismatch-raw-ptr-in-adt.stderr
@@ -8,19 +8,19 @@ LL | struct ConstBytes<const T: &'static [*mut u8; 3]>;
    = note: `[*mut u8; 3]` must implement `ConstParamTy_`, but it does not
 
 error[E0308]: mismatched types
-  --> $DIR/mismatch-raw-ptr-in-adt.rs:9:46
+  --> $DIR/mismatch-raw-ptr-in-adt.rs:9:23
    |
 LL |     let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">;
-   |                                              ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
+   |                       ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
    |
    = note: expected reference `&'static [*mut u8; 3]`
               found reference `&'static [u8; 3]`
 
 error[E0308]: mismatched types
-  --> $DIR/mismatch-raw-ptr-in-adt.rs:9:23
+  --> $DIR/mismatch-raw-ptr-in-adt.rs:9:46
    |
 LL |     let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">;
-   |                       ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
+   |                                              ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
    |
    = note: expected reference `&'static [*mut u8; 3]`
               found reference `&'static [u8; 3]`
diff --git a/tests/ui/const-generics/mgca/generic_const_type_mismatch.rs b/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: type annotations needed for the literal
+};
+
+fn main() {}
diff --git a/tests/ui/const-generics/mgca/generic_const_type_mismatch.stderr b/tests/ui/const-generics/mgca/generic_const_type_mismatch.stderr
@@ -0,0 +1,8 @@
+error: type annotations needed for the literal
+  --> $DIR/generic_const_type_mismatch.rs:17:22
+   |
+LL |     Foo::<T>{field : 1}
+   |                      ^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/const-generics/mgca/tuple_expr_type_mismatch.rs b/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: type annotations needed for the literal
+    //~| ERROR: type annotations needed for the literal
+    bar::<{ (1_u32, [1, 2]) }>();
+    //~^ ERROR: type annotations needed for the literal
+    //~| ERROR: expected `i32`, found const array
+    qux::<{ (1i32, 'a') }>();
+    //~^ ERROR: type annotations needed for the literal
+    //~| ERROR: type annotations needed for the literal
+}
diff --git a/tests/ui/const-generics/mgca/tuple_expr_type_mismatch.stderr b/tests/ui/const-generics/mgca/tuple_expr_type_mismatch.stderr
@@ -0,0 +1,38 @@
+error: type annotations needed for the literal
+  --> $DIR/tuple_expr_type_mismatch.rs:13:14
+   |
+LL |     foo::<{ (1, true) }>();
+   |              ^
+
+error: type annotations needed for the literal
+  --> $DIR/tuple_expr_type_mismatch.rs:13:17
+   |
+LL |     foo::<{ (1, true) }>();
+   |                 ^^^^
+
+error: type annotations needed for the literal
+  --> $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: type annotations needed for the literal
+  --> $DIR/tuple_expr_type_mismatch.rs:19:14
+   |
+LL |     qux::<{ (1i32, 'a') }>();
+   |              ^^^^
+
+error: type annotations needed for the literal
+  --> $DIR/tuple_expr_type_mismatch.rs:19:20
+   |
+LL |     qux::<{ (1i32, 'a') }>();
+   |                    ^^^
+
+error: aborting due to 6 previous errors
+
diff --git a/tests/ui/const-generics/mgca/type_const-mismatched-types.stderr b/tests/ui/const-generics/mgca/type_const-mismatched-types.stderr
@@ -4,6 +4,12 @@ error: the constant `5` is not of type `isize`
 LL | const FREE2: isize = FREE;
    | ^^^^^^^^^^^^^^^^^^ expected `isize`, found `u32`
 
+error[E0308]: mismatched types
+  --> $DIR/type_const-mismatched-types.rs:19:22
+   |
+LL |     const N: usize = false;
+   |                      ^^^^^ expected `usize`, found `bool`
+
 error[E0308]: mismatched types
   --> $DIR/type_const-mismatched-types.rs:5:19
    |
@@ -16,12 +22,6 @@ LL - const FREE: u32 = 5_usize;
 LL + const FREE: u32 = 5_u32;
    |
 
-error[E0308]: mismatched types
-  --> $DIR/type_const-mismatched-types.rs:19:22
-   |
-LL |     const N: usize = false;
-   |                      ^^^^^ expected `usize`, found `bool`
-
 error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr b/tests/ui/const-generics/min_const_generics/invalid-patterns.64bit.stderr
diff --git a/tests/ui/repeat-expr/repeat_count.stderr b/tests/ui/repeat-expr/repeat_count.stderr
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr

Original file line number	Diff line number	Diff line change
`@@ -1412,7 +1412,7 @@ rustc_queries! {`
`1412`	`1412`	`// FIXME get rid of this with valtrees`
`1413`	`1413`	`query lit_to_const(`
`1414`	`1414`	`key: LitToConstInput<'tcx>`
`1415`		`- ) -> ty::Const<'tcx> {`
	`1415`	`+ ) -> Option<ty::Value<'tcx>> {`
`1416`	`1416`	`desc { "converting literal to const" }`
`1417`	`1417`	`}`
`1418`	`1418`
Original file line number	Diff line number	Diff line change
`@@ -256,6 +256,10 @@ impl Erasable for Option<ty::EarlyBinder<'_, Ty<'_>>> {`
`256`	`256`	`type Storage = [u8; size_of::<Option<ty::EarlyBinder<'static, Ty<'static>>>>()];`
`257`	`257`	`}`
`258`	`258`
	`259`	`+impl Erasable for Option<ty::Value<'_>> {`
	`260`	`+ type Storage = [u8; size_of::<Option<ty::Value<'static>>>()];`
	`261`	`+}`
	`262`	`+`
`259`	`263`	`impl Erasable for rustc_hir::MaybeOwner<'_> {`
`260`	`264`	`type Storage = [u8; size_of::<rustc_hir::MaybeOwner<'static>>()];`
`261`	`265`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,10 @@ fn recurse_build<'tcx>(`
`59`	`59`	`}`
`60`	`60`	`&ExprKind::Literal { lit, neg } => {`
`61`	`61`	`let sp = node.span;`
`62`		`- tcx.at(sp).lit_to_const(LitToConstInput { lit: lit.node, ty: node.ty, neg })`
	`62`	`+ match tcx.at(sp).lit_to_const(LitToConstInput { lit: lit.node, ty: node.ty, neg }) {`
	`63`	`+ Some(value) => ty::Const::new_value(tcx, value.valtree, value.ty),`
	`64`	`+ None => ty::Const::new_misc_error(tcx),`
	`65`	`+ }`
`63`	`66`	`}`
`64`	`67`	`&ExprKind::NonHirLiteral { lit, user_ty: _ } => {`
`65`	`68`	`let val = ty::ValTree::from_scalar_int(tcx, lit);`
Original file line number	Diff line number	Diff line change
`@@ -8,19 +8,19 @@ LL \| struct ConstBytes<const T: &'static [*mut u8; 3]>;`
`8`	`8`	= note: `[*mut u8; 3]` must implement `ConstParamTy_`, but it does not
`9`	`9`
`10`	`10`	`error[E0308]: mismatched types`
`11`		`- --> $DIR/mismatch-raw-ptr-in-adt.rs:9:46`
	`11`	`+ --> $DIR/mismatch-raw-ptr-in-adt.rs:9:23`
`12`	`12`	`\|`
`13`	`13`	`LL \| let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">;`
`14`		- \| ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
	`14`	+ \| ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
`15`	`15`	`\|`
`16`	`16`	= note: expected reference `&'static [*mut u8; 3]`
`17`	`17`	found reference `&'static [u8; 3]`
`18`	`18`
`19`	`19`	`error[E0308]: mismatched types`
`20`		`- --> $DIR/mismatch-raw-ptr-in-adt.rs:9:23`
	`20`	`+ --> $DIR/mismatch-raw-ptr-in-adt.rs:9:46`
`21`	`21`	`\|`
`22`	`22`	`LL \| let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">;`
`23`		- \| ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
	`23`	+ \| ^^^^^^ expected `&[*mut u8; 3]`, found `&[u8; 3]`
`24`	`24`	`\|`
`25`	`25`	= note: expected reference `&'static [*mut u8; 3]`
`26`	`26`	found reference `&'static [u8; 3]`