Pretty print pattern type values with transmute if they don't satisfy their pattern

Author: oli-obk

Diff for: compiler/rustc_const_eval/src/lib.rs

@@ -52,6 +52,8 @@ pub fn provide(providers: &mut Providers) {
     providers.check_validity_requirement = |tcx, (init_kind, param_env_and_ty)| {
         util::check_validity_requirement(tcx, init_kind, param_env_and_ty)
     };
+    providers.hooks.validate_scalar_in_layout =
+        |tcx, scalar, layout| util::validate_scalar_in_layout(tcx, scalar, layout);
 }
 
 /// `rustc_driver::main` installs a handler that will set this to `true` if

Diff for: compiler/rustc_const_eval/src/util/check_validity_requirement.rs

@@ -34,7 +34,7 @@ pub fn check_validity_requirement<'tcx>(
 
     let layout_cx = LayoutCx::new(tcx, input.typing_env);
     if kind == ValidityRequirement::Uninit || tcx.sess.opts.unstable_opts.strict_init_checks {
-        check_validity_requirement_strict(layout, &layout_cx, kind)
+        Ok(check_validity_requirement_strict(layout, &layout_cx, kind))
     } else {
         check_validity_requirement_lax(layout, &layout_cx, kind)
     }
@@ -46,7 +46,7 @@ fn check_validity_requirement_strict<'tcx>(
     ty: TyAndLayout<'tcx>,
     cx: &LayoutCx<'tcx>,
     kind: ValidityRequirement,
-) -> Result<bool, &'tcx LayoutError<'tcx>> {
+) -> bool {
     let machine = CompileTimeMachine::new(CanAccessMutGlobal::No, CheckAlignment::Error);
 
     let mut cx = InterpCx::new(cx.tcx(), rustc_span::DUMMY_SP, cx.typing_env, machine);
@@ -69,14 +69,13 @@ fn check_validity_requirement_strict<'tcx>(
     // due to this.
     // The value we are validating is temporary and discarded at the end of this function, so
     // there is no point in reseting provenance and padding.
-    Ok(cx
-        .validate_operand(
-            &allocated.into(),
-            /*recursive*/ false,
-            /*reset_provenance_and_padding*/ false,
-        )
-        .discard_err()
-        .is_some())
+    cx.validate_operand(
+        &allocated.into(),
+        /*recursive*/ false,
+        /*reset_provenance_and_padding*/ false,
+    )
+    .discard_err()
+    .is_some()
 }
 
 /// Implements the 'lax' (default) version of the [`check_validity_requirement`] checks; see that

Diff for: compiler/rustc_const_eval/src/util/mod.rs

@@ -5,11 +5,13 @@ pub(crate) mod caller_location;
 mod check_validity_requirement;
 mod compare_types;
 mod type_name;
+mod validate_scalar_in_layout;
 
 pub use self::alignment::{is_disaligned, is_within_packed};
 pub use self::check_validity_requirement::check_validity_requirement;
 pub use self::compare_types::{relate_types, sub_types};
 pub use self::type_name::type_name;
+pub(crate) use self::validate_scalar_in_layout::validate_scalar_in_layout;
 
 /// Classify whether an operator is "left-homogeneous", i.e., the LHS has the
 /// same type as the result.

Diff for: compiler/rustc_const_eval/src/util/validate_scalar_in_layout.rs

@@ -0,0 +1,30 @@
+use rustc_middle::query::TyCtxtAt;
+use rustc_middle::ty::layout::TyAndLayout;
+use rustc_middle::ty::{self, ScalarInt};
+
+use crate::const_eval::{CanAccessMutGlobal, CheckAlignment, CompileTimeMachine};
+use crate::interpret::{InterpCx, MemoryKind};
+
+pub(crate) fn validate_scalar_in_layout<'tcx>(
+    tcx: TyCtxtAt<'tcx>,
+    scalar: ScalarInt,
+    layout: TyAndLayout<'tcx>,
+) -> bool {
+    let machine = CompileTimeMachine::new(CanAccessMutGlobal::No, CheckAlignment::Error);
+
+    let mut cx = InterpCx::new(tcx.tcx, tcx.span, ty::TypingEnv::fully_monomorphized(), machine);
+
+    let allocated = cx
+        .allocate(layout, MemoryKind::Machine(crate::const_eval::MemoryKind::Heap))
+        .expect("OOM: failed to allocate for uninit check");
+
+    cx.write_scalar(scalar, &allocated).unwrap();
+
+    cx.validate_operand(
+        &allocated.into(),
+        /*recursive*/ false,
+        /*reset_provenance_and_padding*/ false,
+    )
+    .discard_err()
+    .is_some()
+}

Diff for: compiler/rustc_middle/src/hooks/mod.rs

@@ -121,6 +121,8 @@ declare_hooks! {
     hook save_dep_graph() -> ();
 
     hook query_key_hash_verify_all() -> ();
+
+    hook validate_scalar_in_layout(scalar: crate::ty::ScalarInt, layout: crate::ty::layout::TyAndLayout<'tcx>) -> bool;
 }
 
 #[cold]

Diff for: compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1740,7 +1740,12 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                     " as ",
                 )?;
             }
-            ty::Pat(base_ty, pat) => {
+            ty::Pat(base_ty, pat)
+                if self
+                    .tcx()
+                    .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty))
+                    .is_ok_and(|layout| self.tcx().validate_scalar_in_layout(int, layout)) =>
+            {
                 self.pretty_print_const_scalar_int(int, *base_ty, print_ty)?;
                 p!(write(" is {pat:?}"));
             }

Diff for: tests/mir-opt/pattern_types.main.PreCodegen.after.mir

@@ -5,7 +5,7 @@ fn main() -> () {
     scope 1 {
         debug x => const 2_u32 is 1..=;
         scope 2 {
-            debug y => const 0_u32 is 1..=;
+            debug y => const {transmute(0x00000000): (u32) is 1..=};
         }
     }
 

Diff for: tests/mir-opt/pattern_types.rs

@@ -7,6 +7,6 @@ use std::pat::pattern_type;
 fn main() {
     // CHECK: debug x => const 2_u32 is 1..=
     let x: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(2) };
-    // CHECK: debug y => const 0_u32 is 1..=
+    // CHECK: debug y => const {transmute(0x00000000): (u32) is 1..=}
     let y: pattern_type!(u32 is 1..) = unsafe { std::mem::transmute(0) };
 }