also ensure MIR assignment validity during codegen

RalfJung · RalfJung · commit ec0f805fdb4f · 2026-04-19T14:02:01.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
@@ -3774,6 +3774,7 @@ dependencies = [
  "rustc_symbol_mangling",
  "rustc_target",
  "rustc_trait_selection",
+ "rustc_ty_utils",
  "serde_json",
  "smallvec",
  "tempfile",
@@ -3803,6 +3804,7 @@ dependencies = [
  "rustc_span",
  "rustc_target",
  "rustc_trait_selection",
+ "rustc_ty_utils",
  "tracing",
 ]
 
@@ -4407,6 +4409,7 @@ dependencies = [
  "rustc_span",
  "rustc_target",
  "rustc_trait_selection",
+ "rustc_ty_utils",
  "smallvec",
  "tracing",
 ]
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -33,6 +33,7 @@ rustc_span = { path = "../rustc_span" }
 rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
+rustc_ty_utils = { path = "../rustc_ty_utils" }
 serde_json = "1.0.59"
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tempfile = "3.2"
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -5,6 +5,7 @@ use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_session::config::OptLevel;
+use rustc_ty_utils::compare_types;
 use tracing::{debug, instrument};
 
 use super::FunctionCx;
@@ -22,6 +23,27 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         dest: PlaceRef<'tcx, Bx::Value>,
         rvalue: &mir::Rvalue<'tcx>,
     ) {
+        if cfg!(debug_assertions) {
+            // Ensure the rvalue can be assigned to this place. MIR validation ensures that the LHS
+            // and RHS agree on the type, but only here (post-monomorphization) can we check that
+            // they actually have the same layout. This serves as sanity check for subtyping.
+            let rvalue_ty = self.monomorphize(rvalue.ty(&self.mir.local_decls, self.cx.tcx()));
+            let rvalue_layout = self.cx.layout_of(rvalue_ty);
+            if !compare_types::mir_assign_valid_types(
+                self.cx.tcx(),
+                self.cx.typing_env(),
+                rvalue_layout,
+                dest.layout,
+            ) {
+                span_bug!(
+                    self.mir.span, // this is a terrible span but we have nothing better...
+                    "invalid MIR assignment: place has type {}, rvalue has type {}",
+                    dest.layout.ty,
+                    rvalue_ty,
+                )
+            }
+        }
+
         match *rvalue {
             mir::Rvalue::Use(ref operand) => {
                 if let mir::Operand::Constant(const_op) = operand {
@@ -244,6 +266,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         if let abi::BackendRepr::Memory { .. } = cast.backend_repr
             && !cast.is_zst()
         {
+            // This is a terrible span but we have nothing better...
             span_bug!(self.mir.span, "Use `codegen_transmute` to transmute to {cast:?}");
         }
 
diff --git a/compiler/rustc_const_eval/Cargo.toml b/compiler/rustc_const_eval/Cargo.toml
@@ -21,5 +21,6 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
+rustc_ty_utils = { path = "../rustc_ty_utils" }
 tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -10,19 +10,19 @@ use rustc_middle::ty::layout::{
 };
 use rustc_middle::ty::{
     self, GenericArgsRef, Ty, TyCtxt, TypeFoldable, TypeVisitableExt, TypingEnv, TypingMode,
-    Variance,
 };
 use rustc_middle::{bug, mir, span_bug};
 use rustc_span::Span;
 use rustc_target::callconv::FnAbi;
+use rustc_ty_utils::compare_types::mir_assign_valid_types;
 use tracing::{debug, trace};
 
 use super::{
     Frame, FrameInfo, GlobalId, InterpErrorInfo, InterpErrorKind, InterpResult, MPlaceTy, Machine,
     MemPlaceMeta, Memory, OpTy, Place, PlaceTy, PointerArithmetic, Projectable, Provenance,
     err_inval, interp_ok, throw_inval, throw_ub, throw_ub_format,
 };
-use crate::{enter_trace_span, util};
+use crate::enter_trace_span;
 
 pub struct InterpCx<'tcx, M: Machine<'tcx>> {
     /// Stores the `Machine` instance.
@@ -164,38 +164,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     }
 }
 
-/// Test if it is valid for a MIR assignment to assign `src`-typed place to `dest`-typed value.
-pub(super) fn mir_assign_valid_types<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    typing_env: TypingEnv<'tcx>,
-    src: TyAndLayout<'tcx>,
-    dest: TyAndLayout<'tcx>,
-) -> bool {
-    // We *could* check `Invariant` here since all subtyping must be explicit post-borrowck.
-    // However, this check is also used by the interpreter to figure out if a transmute can be
-    // turned into a regular assignment (which has a more efficient codepath), so we want the check
-    // to consider as many assignments as possible to be valid. Therefore we are happy to accept
-    // one-way subtyping.
-    if util::relate_types(tcx, typing_env, Variance::Covariant, src.ty, dest.ty) {
-        // Make sure the layout is equal, too -- just to be safe. Miri really needs layout equality.
-        // For performance reason we skip this check when the types are equal. Equal types *can*
-        // have different layouts when enum downcast is involved (as enum variants carry the type of
-        // the enum), but those should never occur in assignments.
-        if cfg!(debug_assertions) || src.ty != dest.ty {
-            assert_eq!(
-                src.layout,
-                dest.layout,
-                "{src} is a subtype of {dest} but they have different layout",
-                src = src.ty,
-                dest = dest.ty,
-            );
-        }
-        true
-    } else {
-        false
-    }
-}
-
 /// Use the already known layout if given (but sanity check in debug mode),
 /// or compute the layout.
 #[cfg_attr(not(debug_assertions), inline(always))]
diff --git a/compiler/rustc_const_eval/src/interpret/mod.rs b/compiler/rustc_const_eval/src/interpret/mod.rs
@@ -23,8 +23,8 @@ mod visitor;
 pub use rustc_middle::mir::interpret::*; // have all the `interpret` symbols in one place: here
 
 pub use self::call::FnArg;
+use self::eval_context::from_known_layout;
 pub use self::eval_context::{InterpCx, format_interp_error};
-use self::eval_context::{from_known_layout, mir_assign_valid_types};
 pub use self::intern::{
     HasStaticRootDefId, InternError, InternKind, intern_const_alloc_for_constprop,
     intern_const_alloc_recursive,
diff --git a/compiler/rustc_const_eval/src/interpret/operand.rs b/compiler/rustc_const_eval/src/interpret/operand.rs
@@ -13,13 +13,14 @@ use rustc_middle::ty::print::{FmtPrinter, PrettyPrinter};
 use rustc_middle::ty::{ConstInt, ScalarInt, Ty, TyCtxt};
 use rustc_middle::{bug, mir, span_bug, ty};
 use rustc_span::DUMMY_SP;
+use rustc_ty_utils::compare_types::mir_assign_valid_types;
 use tracing::field::Empty;
 use tracing::trace;
 
 use super::{
     CtfeProvenance, Frame, InterpCx, InterpResult, MPlaceTy, Machine, MemPlace, MemPlaceMeta,
     OffsetMode, PlaceTy, Pointer, Projectable, Provenance, Scalar, alloc_range, err_ub,
-    from_known_layout, interp_ok, mir_assign_valid_types, throw_ub,
+    from_known_layout, interp_ok, throw_ub,
 };
 use crate::enter_trace_span;
 
diff --git a/compiler/rustc_const_eval/src/interpret/place.rs b/compiler/rustc_const_eval/src/interpret/place.rs
@@ -9,13 +9,14 @@ use rustc_abi::{BackendRepr, HasDataLayout, Size};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{self, Ty};
 use rustc_middle::{bug, mir, span_bug};
+use rustc_ty_utils::compare_types::mir_assign_valid_types;
 use tracing::field::Empty;
 use tracing::{instrument, trace};
 
 use super::{
     AllocInit, AllocRef, AllocRefMut, CheckAlignMsg, CtfeProvenance, ImmTy, Immediate, InterpCx,
     InterpResult, Machine, MemoryKind, Misalignment, OffsetMode, OpTy, Operand, Pointer,
-    Projectable, Provenance, Scalar, alloc_range, interp_ok, mir_assign_valid_types,
+    Projectable, Provenance, Scalar, alloc_range, interp_ok,
 };
 use crate::enter_trace_span;
 
diff --git a/compiler/rustc_const_eval/src/util/mod.rs b/compiler/rustc_const_eval/src/util/mod.rs
@@ -3,13 +3,11 @@ use rustc_middle::mir;
 mod alignment;
 pub(crate) mod caller_location;
 mod check_validity_requirement;
-mod compare_types;
 mod type_name;
 
 pub use self::alignment::{most_packed_projection, place_unalignment};
 pub use self::check_validity_requirement::check_validity_requirement;
 pub(crate) use self::check_validity_requirement::validate_scalar_in_layout;
-pub use self::compare_types::{relate_types, sub_types};
 pub use self::type_name::type_name;
 
 /// Classify whether an operator is "left-homogeneous", i.e., the LHS has the
diff --git a/compiler/rustc_mir_transform/Cargo.toml b/compiler/rustc_mir_transform/Cargo.toml
@@ -23,6 +23,7 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
+rustc_ty_utils = { path = "../rustc_ty_utils" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
@@ -16,12 +16,13 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Instance, InstanceKind, Ty, TyCtxt, TypeFlags, TypeVisitableExt};
 use rustc_session::config::{DebugInfo, OptLevel};
 use rustc_span::Spanned;
+use rustc_ty_utils::compare_types;
 use tracing::{debug, instrument, trace, trace_span};
 
+use crate::check_inline;
 use crate::cost_checker::{CostChecker, is_call_like};
 use crate::simplify::{UsedInStmtLocals, simplify_cfg};
 use crate::validate::validate_types;
-use crate::{check_inline, util};
 
 pub(crate) mod cycle;
 
@@ -644,7 +645,7 @@ fn try_inlining<'tcx, I: Inliner<'tcx>>(
     // Normally, this shouldn't be required, but trait normalization failure can create a
     // validation ICE.
     let output_type = callee_body.return_ty();
-    if !util::sub_types(tcx, inliner.typing_env(), output_type, destination_ty) {
+    if !compare_types::sub_types(tcx, inliner.typing_env(), output_type, destination_ty) {
         trace!(?output_type, ?destination_ty);
         return Err("implementation limitation -- return type mismatch");
     }
@@ -671,7 +672,7 @@ fn try_inlining<'tcx, I: Inliner<'tcx>>(
             self_arg_ty.into_iter().chain(arg_tys.iter().copied()).zip(callee_body.args_iter())
         {
             let input_type = callee_body.local_decls[input].ty;
-            if !util::sub_types(tcx, inliner.typing_env(), input_type, arg_ty) {
+            if !compare_types::sub_types(tcx, inliner.typing_env(), input_type, arg_ty) {
                 trace!(?arg_ty, ?input_type);
                 debug!("failed to normalize tuple argument type");
                 return Err("implementation limitation");
@@ -681,7 +682,7 @@ fn try_inlining<'tcx, I: Inliner<'tcx>>(
         for (arg, input) in args.iter().zip(callee_body.args_iter()) {
             let input_type = callee_body.local_decls[input].ty;
             let arg_ty = arg.node.ty(&caller_body.local_decls, tcx);
-            if !util::sub_types(tcx, inliner.typing_env(), input_type, arg_ty) {
+            if !compare_types::sub_types(tcx, inliner.typing_env(), input_type, arg_ty) {
                 trace!(?arg_ty, ?input_type);
                 debug!("failed to normalize argument type");
                 return Err("implementation limitation -- arg mismatch");
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
@@ -19,8 +19,9 @@ use rustc_middle::ty::{
 use rustc_middle::{bug, span_bug};
 use rustc_mir_dataflow::debuginfo::debuginfo_locals;
 use rustc_trait_selection::traits::ObligationCtxt;
+use rustc_ty_utils::compare_types;
 
-use crate::util::{self, most_packed_projection};
+use crate::util::most_packed_projection;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum EdgeKind {
@@ -601,7 +602,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             Variance::Covariant
         };
 
-        crate::util::relate_types(self.tcx, self.typing_env, variance, src, dest)
+        compare_types::relate_types(self.tcx, self.typing_env, variance, src, dest)
     }
 
     /// Check that the given predicate definitely holds in the param-env of this MIR body.
@@ -1419,7 +1420,8 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         }
                     }
                     CastKind::Subtype => {
-                        if !util::sub_types(self.tcx, self.typing_env, op_ty, *target_type) {
+                        if !compare_types::sub_types(self.tcx, self.typing_env, op_ty, *target_type)
+                        {
                             self.fail(
                                 location,
                                 format!("Failed subtyping {op_ty} and {target_type}"),
diff --git a/compiler/rustc_ty_utils/src/compare_types.rs b/compiler/rustc_ty_utils/src/compare_types.rs
@@ -1,10 +1,8 @@
 //! Routines to check for relations between fully inferred types.
-//!
-//! FIXME: Move this to a more general place. The utility of this extends to
-//! other areas of the compiler as well.
 
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::traits::ObligationCause;
+use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt, TypingEnv, Variance};
 use rustc_trait_selection::traits::ObligationCtxt;
 
@@ -45,3 +43,35 @@ pub fn relate_types<'tcx>(
     };
     ocx.evaluate_obligations_error_on_ambiguity().is_empty()
 }
+
+/// Test if it is valid for a MIR assignment to assign `src`-typed place to `dest`-typed value.
+pub fn mir_assign_valid_types<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    typing_env: TypingEnv<'tcx>,
+    src: TyAndLayout<'tcx>,
+    dest: TyAndLayout<'tcx>,
+) -> bool {
+    // We *could* check `Invariant` here since all subtyping must be explicit post-borrowck.
+    // However, this check is also used by the interpreter to figure out if a transmute can be
+    // turned into a regular assignment (which has a more efficient codepath), so we want the check
+    // to consider as many assignments as possible to be valid. Therefore we are happy to accept
+    // one-way subtyping.
+    if relate_types(tcx, typing_env, Variance::Covariant, src.ty, dest.ty) {
+        // Make sure the layout is equal, too -- just to be safe. Miri really needs layout equality.
+        // For performance reason we skip this check when the types are equal. Equal types *can*
+        // have different layouts when enum downcast is involved (as enum variants carry the type of
+        // the enum), but those should never occur in assignments.
+        if cfg!(debug_assertions) || src.ty != dest.ty {
+            assert_eq!(
+                src.layout,
+                dest.layout,
+                "{src} is a subtype of {dest} but they have different layout",
+                src = src.ty,
+                dest = dest.ty,
+            );
+        }
+        true
+    } else {
+        false
+    }
+}
diff --git a/compiler/rustc_ty_utils/src/lib.rs b/compiler/rustc_ty_utils/src/lib.rs
@@ -16,6 +16,7 @@ use rustc_middle::query::Providers;
 mod abi;
 mod assoc;
 mod common_traits;
+pub mod compare_types;
 mod consts;
 mod errors;
 mod implied_bounds;
