Replace NullOp::SizeOf and NullOp::AlignOf by lang items.

Author: cjgillot

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1046,16 +1046,6 @@ 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

@@ -73,7 +73,7 @@ pub fn debug_tuple() -> DebugTuple {
 }
 
 pub fn size_of<T>() -> usize {
-    intrinsics::size_of::<T>()
+    const { intrinsics::size_of::<T>() }
 }
 
 pub fn use_size_of() -> usize {

compiler/rustc_codegen_cranelift/src/base.rs

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

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -156,6 +156,24 @@ 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 `NullaryOp::SizeOf`");
+                }
+                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 `NullaryOp::AlignOf`");
+                }
+                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,20 +517,6 @@ 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();

compiler/rustc_hir/src/lang_items.rs

@@ -168,6 +168,10 @@ language_item_table! {
     MetaSized,               sym::meta_sized,          meta_sized_trait,           Target::Trait,          GenericRequirement::Exact(0);
     PointeeSized,            sym::pointee_sized,       pointee_sized_trait,        Target::Trait,          GenericRequirement::Exact(0);
     Unsize,                  sym::unsize,              unsize_trait,               Target::Trait,          GenericRequirement::Minimum(1);
+    AlignOf,                 sym::mem_align_const,     align_const,                Target::AssocConst,     GenericRequirement::Exact(0);
+    SizeOf,                  sym::mem_size_const,      size_const,                 Target::AssocConst,     GenericRequirement::Exact(0);
+    IsZST,                   sym::mem_is_zst_const,    is_zst_const,               Target::AssocConst,     GenericRequirement::Exact(0);
+    IsNotZST,                sym::mem_is_non_zst_const,is_non_zst_const,           Target::AssocConst,     GenericRequirement::Exact(0);
     /// Trait injected by `#[derive(PartialEq)]`, (i.e. "Partial EQ").
     StructuralPeq,           sym::structural_peq,      structural_peq_trait,       Target::Trait,          GenericRequirement::None;
     Copy,                    sym::copy,                copy_trait,                 Target::Trait,          GenericRequirement::Exact(0);

compiler/rustc_middle/src/mir/pretty.rs

@@ -1092,8 +1092,6 @@ impl<'tcx> Debug for Rvalue<'tcx> {
             NullaryOp(ref op, ref t) => {
                 let t = with_no_trimmed_paths!(format!("{}", t));
                 match op {
-                    NullOp::SizeOf => write!(fmt, "SizeOf({t})"),
-                    NullOp::AlignOf => write!(fmt, "AlignOf({t})"),
                     NullOp::OffsetOf(fields) => write!(fmt, "OffsetOf({t}, {fields:?})"),
                     NullOp::UbChecks => write!(fmt, "UbChecks()"),
                     NullOp::ContractChecks => write!(fmt, "ContractChecks()"),

compiler/rustc_middle/src/mir/statement.rs

@@ -782,9 +782,7 @@ impl<'tcx> Rvalue<'tcx> {
                 op.ty(tcx, arg_ty)
             }
             Rvalue::Discriminant(ref place) => place.ty(local_decls, tcx).ty.discriminant_ty(tcx),
-            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(..), _) => {
-                tcx.types.usize
-            }
+            Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => tcx.types.usize,
             Rvalue::NullaryOp(NullOp::ContractChecks, _)
             | Rvalue::NullaryOp(NullOp::UbChecks, _) => tcx.types.bool,
             Rvalue::Aggregate(ref ak, ref ops) => match **ak {
@@ -853,7 +851,7 @@ impl BorrowKind {
 impl<'tcx> NullOp<'tcx> {
     pub fn ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self {
-            NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_) => tcx.types.usize,
+            NullOp::OffsetOf(_) => tcx.types.usize,
             NullOp::UbChecks | NullOp::ContractChecks => tcx.types.bool,
         }
     }