CastKind::Transmute is only allowed in MirPhase::Runtime

Author: scottmcm

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2246,7 +2246,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                         span_mirbug!(
                             self,
                             rvalue,
-                            "Unexpected CastKind::Transmute, should only appear after lowering_intrinsics",
+                            "Unexpected CastKind::Transmute, which is not permitted in Analysis MIR",
                         );
                     }
                 }

compiler/rustc_const_eval/src/transform/validate.rs

@@ -620,23 +620,41 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         }
                     }
                     CastKind::Transmute => {
-                        let src_layout = self.tcx.layout_of(self.param_env.and(op_ty));
-                        let dst_layout = self.tcx.layout_of(self.param_env.and(*target_type));
-                        if let Err(e) = src_layout {
+                        if let MirPhase::Runtime(..) = self.mir_phase {
+                            // `mem::transmute` currently requires types concrete enough
+                            // to *know* that their sizes are the same, and we repeat
+                            // that check here.  This restriction may be lifted in future,
+                            // should some optimizations need to it be more general.
+                            // (It might just end up being UB if they don't match, say.)
+
+                            let src_layout = self.tcx.layout_of(self.param_env.and(op_ty));
+                            let dst_layout = self.tcx.layout_of(self.param_env.and(*target_type));
+                            if let Err(e) = src_layout {
+                                self.fail(
+                                    location,
+                                    format!(
+                                        "Unable to compute layout for source type {op_ty:?}: {e}"
+                                    ),
+                                );
+                            }
+                            if let Err(e) = dst_layout {
+                                self.fail(location, format!("Unable to compute layout for destination type {target_type:?}: {e}"));
+                            }
+
+                            if let (Ok(src_layout), Ok(dst_layout)) = (src_layout, dst_layout) {
+                                if src_layout.layout.size() != dst_layout.layout.size() {
+                                    self.fail(location, format!("Source and destination layouts have different sizes: {src_layout:?} vs {dst_layout:?}"));
+                                }
+                            }
+                        } else {
                             self.fail(
                                 location,
-                                format!("Unable to compute layout for source type {op_ty:?}: {e}"),
+                                format!(
+                                    "Transmute is not supported in non-runtime phase {:?}.",
+                                    self.mir_phase
+                                ),
                             );
                         }
-                        if let Err(e) = dst_layout {
-                            self.fail(location, format!("Unable to compute layout for destination type {target_type:?}: {e}"));
-                        }
-
-                        if let (Ok(src_layout), Ok(dst_layout)) = (src_layout, dst_layout) {
-                            if src_layout.layout.size() != dst_layout.layout.size() {
-                                self.fail(location, format!("Source and destination layouts have different sizes: {src_layout:?} vs {dst_layout:?}"));
-                            }
-                        }
                     }
                 }
             }

compiler/rustc_middle/src/mir/syntax.rs

@@ -83,6 +83,9 @@ pub enum MirPhase {
     ///    access to. This occurs in generator bodies. Such locals do not behave like other locals,
     ///    because they eg may be aliased in surprising ways. Runtime MIR has no such special locals -
     ///    all generator bodies are lowered and so all places that look like locals really are locals.
+    ///  - Intrinsics: In analysis MIR, intrinsics are typically represented as [`TerminatorKind::Call`]s
+    ///    to their `extern "rust-intrinsic"` declarations.  In runtime MIR, some intrinsics are lowered
+    ///    to MIR constructs not used earlier, such as `mem::transmute` → [`CastKind::Transmute`].
     ///
     /// Also note that the lint pass which reports eg `200_u8 + 200_u8` as an error is run as a part
     /// of analysis to runtime MIR lowering. To ensure lints are reported reliably, this means that
@@ -1190,6 +1193,8 @@ pub enum CastKind {
     PtrToPtr,
     FnPtrToPtr,
     /// Reinterpret the bits of the input as a different type.
+    ///
+    /// Allowed only in [`MirPhase::Runtime`]; Earlier it's a [`TerminatorKind::Call`].
     Transmute,
 }