Extend the enum check to pointer and union reads

compiler/rustc_codegen_cranelift/src/base.rs

@@ -422,14 +422,15 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
                             source_info.span,
                         )
                     }
-                    AssertKind::InvalidEnumConstruction(source) => {
+                    AssertKind::InvalidEnumConstruction(ty, source) => {
+                        let ty = codegen_operand(fx, ty).load_scalar(fx);
                         let source = codegen_operand(fx, source).load_scalar(fx);
                         let location = fx.get_caller_location(source_info).load_scalar(fx);
 
                         codegen_panic_inner(
                             fx,
                             rustc_hir::LangItem::PanicInvalidEnumConstruction,
-                            &[source, location],
+                            &[ty, source, location],
                             *unwind,
                             source_info.span,
                         )

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -24,6 +24,7 @@ use super::{CachedLlbb, FunctionCx, LocalRef};
 use crate::base::{self, is_call_from_compiler_builtins_to_upstream_monomorphization};
 use crate::common::{self, IntPredicate};
 use crate::errors::CompilerBuiltinsCannotCall;
+use crate::mir::operand::OperandValue;
 use crate::traits::*;
 use crate::{MemFlags, meth};
 
@@ -761,11 +762,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 // `#[track_caller]` adds an implicit argument.
                 (LangItem::PanicNullPointerDereference, vec![location])
             }
-            AssertKind::InvalidEnumConstruction(source) => {
+            AssertKind::InvalidEnumConstruction(ty, source) => {
                 let source = self.codegen_operand(bx, source).immediate();
+                let OperandValue::Pair(ptr, len) = self.codegen_operand(bx, ty).val else {
+                    panic!("What the hell?");
+                };
+                let ptr = ptr;
+                let len = len;
                 // It's `fn panic_invalid_enum_construction(source: u128)`,
                 // `#[track_caller]` adds an implicit argument.
-                (LangItem::PanicInvalidEnumConstruction, vec![source, location])
+                (LangItem::PanicInvalidEnumConstruction, vec![ptr, len, source, location])
             }
             _ => {
                 // It's `pub fn panic_...()` and `#[track_caller]` adds an implicit argument.

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -652,7 +652,9 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 found: eval_to_int(found)?,
             },
             NullPointerDereference => NullPointerDereference,
-            InvalidEnumConstruction(source) => InvalidEnumConstruction(eval_to_int(source)?),
+            InvalidEnumConstruction(ty, source) => {
+                InvalidEnumConstruction(eval_to_int(ty)?, eval_to_int(source)?)
+            }
         };
         Err(ConstEvalErrKind::AssertFailure(err)).into()
     }

compiler/rustc_middle/src/mir/syntax.rs

@@ -1074,7 +1074,7 @@ pub enum AssertKind<O> {
     ResumedAfterDrop(CoroutineKind),
     MisalignedPointerDereference { required: O, found: O },
     NullPointerDereference,
-    InvalidEnumConstruction(O),
+    InvalidEnumConstruction(O, O),
 }
 
 #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, Hash, HashStable)]

compiler/rustc_middle/src/mir/terminator.rs

@@ -208,7 +208,7 @@ impl<O> AssertKind<O> {
                 LangItem::PanicGenFnNonePanic
             }
             NullPointerDereference => LangItem::PanicNullPointerDereference,
-            InvalidEnumConstruction(_) => LangItem::PanicInvalidEnumConstruction,
+            InvalidEnumConstruction(..) => LangItem::PanicInvalidEnumConstruction,
             ResumedAfterDrop(CoroutineKind::Coroutine(_)) => LangItem::PanicCoroutineResumedDrop,
             ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) => {
                 LangItem::PanicAsyncFnResumedDrop
@@ -285,8 +285,11 @@ impl<O> AssertKind<O> {
                 )
             }
             NullPointerDereference => write!(f, "\"null pointer dereference occurred\""),
-            InvalidEnumConstruction(source) => {
-                write!(f, "\"trying to construct an enum from an invalid value {{}}\", {source:?}")
+            InvalidEnumConstruction(ty, source) => {
+                write!(
+                    f,
+                    "\"trying to construct an enum from an invalid value {{}}; type {{}}\", {source:?}, {ty:?}"
+                )
             }
             ResumedAfterReturn(CoroutineKind::Coroutine(_)) => {
                 write!(f, "\"coroutine resumed after completion\"")
@@ -379,7 +382,7 @@ impl<O> AssertKind<O> {
                 msg!("coroutine resumed after panicking")
             }
             NullPointerDereference => msg!("null pointer dereference occurred"),
-            InvalidEnumConstruction(_) => {
+            InvalidEnumConstruction(..) => {
                 msg!("trying to construct an enum from an invalid value `{$source}`")
             }
             ResumedAfterDrop(CoroutineKind::Desugared(CoroutineDesugaring::Async, _)) => {
@@ -437,8 +440,9 @@ impl<O> AssertKind<O> {
                 add!("required", format!("{required:#?}"));
                 add!("found", format!("{found:#?}"));
             }
-            InvalidEnumConstruction(source) => {
+            InvalidEnumConstruction(ty, source) => {
                 add!("source", format!("{source:#?}"));
+                add!("ty", format!("{ty:#?}"));
             }
         }
     }

compiler/rustc_middle/src/mir/visit.rs

@@ -685,7 +685,11 @@ macro_rules! make_mir_visitor {
                         self.visit_operand(l, location);
                         self.visit_operand(r, location);
                     }
-                    OverflowNeg(op) | DivisionByZero(op) | RemainderByZero(op) | InvalidEnumConstruction(op) => {
+                    OverflowNeg(op) | DivisionByZero(op) | RemainderByZero(op) => {
+                        self.visit_operand(op, location);
+                    }
+                    InvalidEnumConstruction(ty, op) => {
+                        self.visit_operand(ty, location);
                         self.visit_operand(op, location);
                     }
                     ResumedAfterReturn(_) | ResumedAfterPanic(_) | NullPointerDereference | ResumedAfterDrop(_) => {