Auto merge of #149649 - wesleywiser:revert_147793, r=wesleywiser

[beta] Revert "Replace NullOp::SizeOf and NullOp::AlignOf by lang items."

Totally clean revert, tests pass on my local machine.

Fixes #149081 on 1.92 beta

cc `@lcnr` `@BoxyUwU` `@jieyouxu` `@cjgillot`

Author: bors

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1046,6 +1046,16 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 }
             }
 
+            &Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf, ty) => {
+                let trait_ref =
+                    ty::TraitRef::new(tcx, tcx.require_lang_item(LangItem::Sized, span), [ty]);
+
+                self.prove_trait_ref(
+                    trait_ref,
+                    location.to_locations(),
+                    ConstraintCategory::SizedBound,
+                );
+            }
             &Rvalue::NullaryOp(NullOp::ContractChecks, _) => {}
             &Rvalue::NullaryOp(NullOp::UbChecks, _) => {}
 

compiler/rustc_codegen_cranelift/example/example.rs

@@ -72,6 +72,10 @@ pub fn debug_tuple() -> DebugTuple {
     DebugTuple(())
 }
 
+pub fn size_of<T>() -> usize {
+    intrinsics::size_of::<T>()
+}
+
 pub fn use_size_of() -> usize {
     size_of::<u64>()
 }

compiler/rustc_codegen_cranelift/example/mini_core.rs

@@ -6,7 +6,6 @@
     extern_types,
     decl_macro,
     rustc_attrs,
-    rustc_private,
     transparent_unions,
     auto_traits,
     freeze_impls,
@@ -595,7 +594,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Box<U>> for Box<T> {}
 impl<T> Box<T> {
     pub fn new(val: T) -> Box<T> {
         unsafe {
-            let size = size_of::<T>();
+            let size = intrinsics::size_of::<T>();
             let ptr = libc::malloc(size);
             intrinsics::copy(&val as *const T as *const u8, ptr, size);
             Box(Unique { pointer: NonNull(ptr as *const T), _marker: PhantomData }, Global)
@@ -647,11 +646,11 @@ pub mod intrinsics {
     #[rustc_intrinsic]
     pub fn abort() -> !;
     #[rustc_intrinsic]
-    pub const fn size_of<T>() -> usize;
+    pub fn size_of<T>() -> usize;
     #[rustc_intrinsic]
     pub unsafe fn size_of_val<T: ?::Sized>(val: *const T) -> usize;
     #[rustc_intrinsic]
-    pub const fn align_of<T>() -> usize;
+    pub fn align_of<T>() -> usize;
     #[rustc_intrinsic]
     pub unsafe fn align_of_val<T: ?::Sized>(val: *const T) -> usize;
     #[rustc_intrinsic]
@@ -716,23 +715,6 @@ impl<T> Index<usize> for [T] {
     }
 }
 
-pub const fn size_of<T>() -> usize {
-    <T as SizedTypeProperties>::SIZE
-}
-
-pub const fn align_of<T>() -> usize {
-    <T as SizedTypeProperties>::ALIGN
-}
-
-trait SizedTypeProperties: Sized {
-    #[lang = "mem_size_const"]
-    const SIZE: usize = intrinsics::size_of::<Self>();
-
-    #[lang = "mem_align_const"]
-    const ALIGN: usize = intrinsics::align_of::<Self>();
-}
-impl<T> SizedTypeProperties for T {}
-
 extern "C" {
     type VaListImpl;
 }

compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs

@@ -109,10 +109,10 @@ fn start<T: Termination + 'static>(
             puts(*argv as *const i8);
         }
         unsafe {
-            puts(*((argv as usize + size_of::<*const u8>()) as *const *const i8));
+            puts(*((argv as usize + intrinsics::size_of::<*const u8>()) as *const *const i8));
         }
         unsafe {
-            puts(*((argv as usize + 2 * size_of::<*const u8>()) as *const *const i8));
+            puts(*((argv as usize + 2 * intrinsics::size_of::<*const u8>()) as *const *const i8));
         }
     }
 
@@ -213,8 +213,8 @@ fn main() {
         assert_eq!(intrinsics::size_of_val(a) as u8, 16);
         assert_eq!(intrinsics::size_of_val(&0u32) as u8, 4);
 
-        assert_eq!(align_of::<u16>() as u8, 2);
-        assert_eq!(intrinsics::align_of_val(&a) as u8, align_of::<&str>() as u8);
+        assert_eq!(intrinsics::align_of::<u16>() as u8, 2);
+        assert_eq!(intrinsics::align_of_val(&a) as u8, intrinsics::align_of::<&str>() as u8);
 
         let u8_needs_drop = const { intrinsics::needs_drop::<u8>() };
         assert!(!u8_needs_drop);

compiler/rustc_codegen_cranelift/src/base.rs

@@ -833,6 +833,8 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     assert!(lval.layout().ty.is_sized(fx.tcx, fx.typing_env()));
                     let layout = fx.layout_of(fx.monomorphize(ty));
                     let val = match null_op {
+                        NullOp::SizeOf => layout.size.bytes(),
+                        NullOp::AlignOf => layout.align.bytes(),
                         NullOp::OffsetOf(fields) => fx
                             .tcx
                             .offset_of_subfield(

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -611,6 +611,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let ty = self.monomorphize(ty);
                 let layout = bx.cx().layout_of(ty);
                 let val = match null_op {
+                    mir::NullOp::SizeOf => {
+                        assert!(bx.cx().type_is_sized(ty));
+                        let val = layout.size.bytes();
+                        bx.cx().const_usize(val)
+                    }
+                    mir::NullOp::AlignOf => {
+                        assert!(bx.cx().type_is_sized(ty));
+                        let val = layout.align.bytes();
+                        bx.cx().const_usize(val)
+                    }
                     mir::NullOp::OffsetOf(fields) => {
                         let val = bx
                             .tcx()

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -646,7 +646,11 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
             Rvalue::Cast(_, _, _) => {}
 
             Rvalue::NullaryOp(
-                NullOp::OffsetOf(_) | NullOp::UbChecks | NullOp::ContractChecks,
+                NullOp::SizeOf
+                | NullOp::AlignOf
+                | NullOp::OffsetOf(_)
+                | NullOp::UbChecks
+                | NullOp::ContractChecks,
                 _,
             ) => {}
             Rvalue::ShallowInitBox(_, _) => {}

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -414,6 +414,8 @@ fn report_eval_error<'tcx>(
     let (error, backtrace) = error.into_parts();
     backtrace.print_backtrace();
 
+    let instance = with_no_trimmed_paths!(cid.instance.to_string());
+
     super::report(
         ecx,
         error,
@@ -428,7 +430,7 @@ fn report_eval_error<'tcx>(
                 diag.subdiagnostic(frame);
             }
             // Add after the frame rendering above, as it adds its own `instance` args.
-            diag.arg("instance", with_no_trimmed_paths!(cid.instance.to_string()));
+            diag.arg("instance", instance);
             diag.arg("num_frames", num_frames);
         },
     )

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -156,24 +156,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let b_ty = self.read_type_id(&args[1])?;
                 self.write_scalar(Scalar::from_bool(a_ty == b_ty), dest)?;
             }
-            sym::size_of => {
-                let tp_ty = instance.args.type_at(0);
-                let layout = self.layout_of(tp_ty)?;
-                if !layout.is_sized() {
-                    span_bug!(self.cur_span(), "unsized type for `size_of`");
-                }
-                let val = layout.size.bytes();
-                self.write_scalar(Scalar::from_target_usize(val, self), dest)?;
-            }
-            sym::align_of => {
-                let tp_ty = instance.args.type_at(0);
-                let layout = self.layout_of(tp_ty)?;
-                if !layout.is_sized() {
-                    span_bug!(self.cur_span(), "unsized type for `align_of`");
-                }
-                let val = layout.align.bytes();
-                self.write_scalar(Scalar::from_target_usize(val, self), dest)?;
-            }
             sym::variant_count => {
                 let tp_ty = instance.args.type_at(0);
                 let ty = match tp_ty.kind() {

compiler/rustc_const_eval/src/interpret/operator.rs

@@ -517,6 +517,20 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         let usize_layout = || self.layout_of(self.tcx.types.usize).unwrap();
 
         interp_ok(match null_op {
+            SizeOf => {
+                if !layout.is_sized() {
+                    span_bug!(self.cur_span(), "unsized type for `NullaryOp::SizeOf`");
+                }
+                let val = layout.size.bytes();
+                ImmTy::from_uint(val, usize_layout())
+            }
+            AlignOf => {
+                if !layout.is_sized() {
+                    span_bug!(self.cur_span(), "unsized type for `NullaryOp::AlignOf`");
+                }
+                let val = layout.align.bytes();
+                ImmTy::from_uint(val, usize_layout())
+            }
             OffsetOf(fields) => {
                 let val =
                     self.tcx.offset_of_subfield(self.typing_env, layout, fields.iter()).bytes();