Remove NullOp

Author: nilehmann

crates/flux-refineck/src/checker.rs

@@ -1287,7 +1287,7 @@ impl<'ck, 'genv, 'tcx, M: Mode> Checker<'ck, 'genv, 'tcx, M> {
                 self.check_binary_op(infcx, env, stmt_span, *bin_op, op1, op2)
                     .with_span(stmt_span)
             }
-            Rvalue::NullaryOp(null_op, ty) => Ok(self.check_nullary_op(*null_op, ty)),
+
             Rvalue::UnaryOp(UnOp::PtrMetadata, Operand::Copy(place))
             | Rvalue::UnaryOp(UnOp::PtrMetadata, Operand::Move(place)) => {
                 self.check_raw_ptr_metadata(infcx, env, stmt_span, place)
@@ -1413,16 +1413,6 @@ impl<'ck, 'genv, 'tcx, M: Mode> Checker<'ck, 'genv, 'tcx, M> {
         }
     }
 
-    fn check_nullary_op(&self, null_op: mir::NullOp, _ty: &ty::Ty) -> Ty {
-        match null_op {
-            mir::NullOp::SizeOf | mir::NullOp::AlignOf => {
-                // We could try to get the layout of type to index this with the actual value, but
-                // this enough for now. Revisit if we ever need the precision.
-                Ty::uint(UintTy::Usize)
-            }
-        }
-    }
-
     fn check_unary_op(
         &mut self,
         infcx: &mut InferCtxt<'_, 'genv, 'tcx>,

crates/flux-refineck/src/ghost_statements/fold_unfold.rs

@@ -335,7 +335,6 @@ impl<M: Mode> FoldUnfoldAnalysis<'_, '_, '_, M> {
                     Rvalue::Repeat(op, _) => {
                         self.operand(op, env)?;
                     }
-                    Rvalue::NullaryOp(_, _) => {}
                 }
                 M::projection(self, env, place)?;
             }

crates/flux-rustc-bridge/src/lowering.rs

@@ -21,7 +21,7 @@ use rustc_trait_selection::traits::SelectionContext;
 use super::{
     mir::{
         AggregateKind, AssertKind, BasicBlockData, BinOp, Body, CallArgs, CastKind, Constant,
-        LocalDecl, NonDivergingIntrinsic, NullOp, Operand, Place, PlaceElem, PointerCast, Rvalue,
+        LocalDecl, NonDivergingIntrinsic, Operand, Place, PlaceElem, PointerCast, Rvalue,
         Statement, StatementKind, Terminator, TerminatorKind,
     },
     ty::{
@@ -469,9 +469,6 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> {
                     self.lower_operand(op2)?,
                 ))
             }
-            rustc_mir::Rvalue::NullaryOp(null_op, ty) => {
-                Ok(Rvalue::NullaryOp(self.lower_null_op(*null_op)?, ty.lower(self.tcx)?))
-            }
             rustc_mir::Rvalue::UnaryOp(un_op, op) => {
                 Ok(Rvalue::UnaryOp(*un_op, self.lower_operand(op)?))
             }
@@ -487,6 +484,7 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> {
                 Ok(Rvalue::ShallowInitBox(self.lower_operand(op)?, ty.lower(self.tcx)?))
             }
             rustc_mir::Rvalue::ThreadLocalRef(_)
+            | rustc_mir::Rvalue::NullaryOp(..)
             | rustc_mir::Rvalue::CopyForDeref(_)
             | rustc_mir::Rvalue::WrapUnsafeBinder(..) => {
                 Err(UnsupportedReason::new(format!("unsupported rvalue `{rvalue:?}`")))
@@ -602,18 +600,6 @@ impl<'sess, 'tcx> MirLoweringCtxt<'_, 'sess, 'tcx> {
         }
     }
 
-    fn lower_null_op(&self, null_op: rustc_mir::NullOp) -> Result<NullOp, UnsupportedReason> {
-        match null_op {
-            rustc_mir::NullOp::SizeOf => Ok(NullOp::SizeOf),
-            rustc_mir::NullOp::AlignOf => Ok(NullOp::AlignOf),
-            rustc_mir::NullOp::OffsetOf(_)
-            | rustc_mir::NullOp::UbChecks
-            | rustc_mir::NullOp::ContractChecks => {
-                Err(UnsupportedReason::new(format!("unsupported nullary op `{null_op:?}`")))
-            }
-        }
-    }
-
     fn lower_operand(&self, op: &rustc_mir::Operand<'tcx>) -> Result<Operand, UnsupportedReason> {
         match op {
             rustc_mir::Operand::Copy(place) => Ok(Operand::Copy(lower_place(self.tcx, place)?)),

crates/flux-rustc-bridge/src/mir.rs

@@ -209,7 +209,6 @@ pub enum Rvalue {
     RawPtr(RawPtrKind, Place),
     Cast(CastKind, Operand, Ty),
     BinaryOp(BinOp, Operand, Operand),
-    NullaryOp(NullOp, Ty),
     UnaryOp(UnOp, Operand),
     Discriminant(Place),
     Aggregate(AggregateKind, Vec<Operand>),
@@ -264,12 +263,6 @@ pub enum BinOp {
     Shr,
 }
 
-#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
-pub enum NullOp {
-    SizeOf,
-    AlignOf,
-}
-
 pub enum Operand {
     Copy(Place),
     Move(Place),
@@ -681,7 +674,6 @@ impl fmt::Debug for Rvalue {
             Rvalue::RawPtr(mutbl, place) => write!(f, "&raw {} {place:?}", mutbl.ptr_str()),
             Rvalue::Discriminant(place) => write!(f, "discriminant({place:?})"),
             Rvalue::BinaryOp(bin_op, op1, op2) => write!(f, "{bin_op:?}({op1:?}, {op2:?})"),
-            Rvalue::NullaryOp(null_op, ty) => write!(f, "{null_op:?}({ty:?})"),
             Rvalue::UnaryOp(un_op, op) => write!(f, "{un_op:?}({op:?})"),
             Rvalue::Aggregate(AggregateKind::Adt(def_id, variant_idx, args, _, _), operands) => {
                 let (fname, variant_name) = rustc_middle::ty::tls::with(|tcx| {