change NullOp::OffsetOf to NullOp::FieldOffset that expects a ty::Field argument ty

BennoLossin · BennoLossin · commit 4bee06cabe8a · 2025-09-09T14:29:08.000+02:00
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1624,6 +1624,12 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 )
                 .unwrap();
             }
+            Rvalue::NullaryOp(NullOp::FieldOffset, ty) => match ty.kind() {
+                ty::Field(..) => {}
+                _ => bug!(
+                    "FIXME(field_projections): should we report an error here, or `span_mirbug!`?"
+                ),
+            },
 
             Rvalue::Use(_)
             | Rvalue::UnaryOp(_, _)
@@ -1632,8 +1638,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             | Rvalue::RawPtr(..)
             | Rvalue::ThreadLocalRef(..)
             | Rvalue::Len(..)
-            | Rvalue::Discriminant(..)
-            | Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}
+            | Rvalue::Discriminant(..) => {}
         }
     }
 
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -8,6 +8,7 @@ use rustc_ast::InlineAsmOptions;
 use rustc_codegen_ssa::base::is_call_from_compiler_builtins_to_upstream_monomorphization;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_index::IndexVec;
+use rustc_middle::bug;
 use rustc_middle::ty::TypeVisitableExt;
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv};
@@ -853,14 +854,19 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     let val = match null_op {
                         NullOp::SizeOf => layout.size.bytes(),
                         NullOp::AlignOf => layout.align.abi.bytes(),
-                        NullOp::OffsetOf(fields) => fx
-                            .tcx
-                            .offset_of_subfield(
-                                ty::TypingEnv::fully_monomorphized(),
-                                layout,
-                                fields.iter(),
-                            )
-                            .bytes(),
+                        NullOp::FieldOffset => {
+                            let &ty::Field(container, field_path) = layout.ty.kind() else {
+                                bug!("FIXME(field_projections): better error")
+                            };
+                            let layout = fx.layout_of(container);
+                            fx.tcx
+                                .offset_of_subfield(
+                                    ty::TypingEnv::fully_monomorphized(),
+                                    layout,
+                                    field_path.iter(),
+                                )
+                                .bytes()
+                        }
                         NullOp::UbChecks => {
                             let val = fx.tcx.sess.ub_checks();
                             let val = CValue::by_val(
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -619,10 +619,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         let val = layout.align.abi.bytes();
                         bx.cx().const_usize(val)
                     }
-                    mir::NullOp::OffsetOf(fields) => {
+                    mir::NullOp::FieldOffset => {
+                        let &ty::Field(container, field_path) = ty.kind() else {
+                            bug!("expected `ty::Field` for `NullOp::FieldOffset`, but got {ty:?}")
+                        };
+                        let layout = bx.cx().layout_of(container);
                         let val = bx
                             .tcx()
-                            .offset_of_subfield(bx.typing_env(), layout, fields.iter())
+                            .offset_of_subfield(bx.typing_env(), layout, field_path.iter())
                             .bytes();
                         bx.cx().const_usize(val)
                     }
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -649,7 +649,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
             Rvalue::NullaryOp(
                 NullOp::SizeOf
                 | NullOp::AlignOf
-                | NullOp::OffsetOf(_)
+                | NullOp::FieldOffset
                 | NullOp::UbChecks
                 | NullOp::ContractChecks,
                 _,
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -7,10 +7,10 @@ use std::assert_matches::assert_matches;
 use rustc_abi::{FieldIdx, HasDataLayout, Size};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, read_target_uint, write_target_uint};
-use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic, NullOp};
+use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt};
-use rustc_middle::{bug, err_inval, span_bug, ty};
+use rustc_middle::{bug, ty};
 use rustc_span::{Symbol, sym};
 use tracing::trace;
 
@@ -638,8 +638,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 rustc_apfloat::Round::NearestTiesToEven,
             )?,
 
-            sym::unaligned_field_offset => self.unaligned_field_offset(instance, dest)?,
-
             // Unsupported intrinsic: skip the return_to_block below.
             _ => return interp_ok(false),
         }
@@ -649,25 +647,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(true)
     }
 
-    fn unaligned_field_offset(
-        &mut self,
-        instance: ty::Instance<'tcx>,
-        dest: &PlaceTy<'tcx, M::Provenance>,
-    ) -> InterpResult<'tcx, ()> {
-        assert_eq!(instance.args.len(), 1);
-        let ty = instance.args.type_at(0);
-        match ty.kind() {
-            &ty::Field(container, field_path) => {
-                let offset = self.nullary_op(NullOp::OffsetOf(field_path), container)?;
-                self.write_immediate(*offset, dest)
-            }
-            ty::Alias(..) | ty::Param(..) | ty::Placeholder(..) | ty::Infer(..) => {
-                Err(err_inval!(TooGeneric)).into()
-            }
-            _ => span_bug!(self.cur_span(), "expected field representing type, found {ty}"),
-        }
-    }
-
     pub(super) fn eval_nondiverging_intrinsic(
         &mut self,
         intrinsic: &NonDivergingIntrinsic<'tcx>,
diff --git a/compiler/rustc_const_eval/src/interpret/operator.rs b/compiler/rustc_const_eval/src/interpret/operator.rs
@@ -508,7 +508,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
     pub fn nullary_op(
         &self,
-        null_op: NullOp<'tcx>,
+        null_op: NullOp,
         arg_ty: Ty<'tcx>,
     ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
         use rustc_middle::mir::NullOp::*;
@@ -531,9 +531,16 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let val = layout.align.abi.bytes();
                 ImmTy::from_uint(val, usize_layout())
             }
-            OffsetOf(fields) => {
+            FieldOffset => {
+                let &ty::Field(container, field_path) = arg_ty.kind() else {
+                    span_bug!(
+                        self.cur_span(),
+                        "expected `ty::Field` for `NullOp::FieldOffset`, but got {arg_ty:?}"
+                    )
+                };
+                let layout = self.layout_of(container)?;
                 let val =
-                    self.tcx.offset_of_subfield(self.typing_env, layout, fields.iter()).bytes();
+                    self.tcx.offset_of_subfield(self.typing_env, layout, field_path.iter()).bytes();
                 ImmTy::from_uint(val, usize_layout())
             }
             UbChecks => ImmTy::from_bool(M::ub_checks(self)?, *self.tcx),
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1072,7 +1072,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                 match op {
                     NullOp::SizeOf => write!(fmt, "SizeOf({t})"),
                     NullOp::AlignOf => write!(fmt, "AlignOf({t})"),
-                    NullOp::OffsetOf(fields) => write!(fmt, "OffsetOf({t}, {fields:?})"),
+                    NullOp::FieldOffset => write!(fmt, "FieldOffset({t})"),
                     NullOp::UbChecks => write!(fmt, "UbChecks()"),
                     NullOp::ContractChecks => write!(fmt, "ContractChecks()"),
                 }
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
@@ -751,7 +751,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(..), _) => {
+            Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::FieldOffset, _) => {
                 tcx.types.usize
             }
             Rvalue::NullaryOp(NullOp::ContractChecks, _)
@@ -819,10 +819,10 @@ impl BorrowKind {
     }
 }
 
-impl<'tcx> NullOp<'tcx> {
-    pub fn ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
+impl NullOp {
+    pub fn ty<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self {
-            NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_) => tcx.types.usize,
+            NullOp::SizeOf | NullOp::AlignOf | NullOp::FieldOffset => tcx.types.usize,
             NullOp::UbChecks | NullOp::ContractChecks => tcx.types.bool,
         }
     }
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
@@ -19,7 +19,7 @@ use smallvec::SmallVec;
 use super::{BasicBlock, Const, Local, UserTypeProjection};
 use crate::mir::coverage::CoverageKind;
 use crate::ty::adjustment::PointerCoercion;
-use crate::ty::{self, FieldPath, GenericArgsRef, List, Region, Ty, UserTypeAnnotationIndex};
+use crate::ty::{self, GenericArgsRef, List, Region, Ty, UserTypeAnnotationIndex};
 
 /// Represents the "flavors" of MIR.
 ///
@@ -1439,7 +1439,7 @@ pub enum Rvalue<'tcx> {
     BinaryOp(BinOp, Box<(Operand<'tcx>, Operand<'tcx>)>),
 
     /// Computes a value as described by the operation.
-    NullaryOp(NullOp<'tcx>, Ty<'tcx>),
+    NullaryOp(NullOp, Ty<'tcx>),
 
     /// Exactly like `BinaryOp`, but less operands.
     ///
@@ -1568,13 +1568,13 @@ pub enum AggregateKind<'tcx> {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
-pub enum NullOp<'tcx> {
+pub enum NullOp {
     /// Returns the size of a value of that type
     SizeOf,
     /// Returns the minimum alignment of a type
     AlignOf,
-    /// Returns the offset of a field
-    OffsetOf(FieldPath<'tcx>),
+    /// Returns the offset of the field represented by the type
+    FieldOffset,
     /// Returns whether we should perform some UB-checking at runtime.
     /// See the `ub_checks` intrinsic docs for details.
     UbChecks,
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -253,7 +253,7 @@ TrivialTypeTraversalImpls! {
     crate::mir::FakeReadCause,
     crate::mir::Local,
     crate::mir::MirPhase,
-    crate::mir::NullOp<'tcx>,
+    crate::mir::NullOp,
     crate::mir::Promoted,
     crate::mir::RawPtrKind,
     crate::mir::RetagKind,
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -419,9 +419,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 }))))
             }
 
-            ExprKind::OffsetOf { container, fields } => {
-                block.and(Rvalue::NullaryOp(NullOp::OffsetOf(fields), container))
-            }
+            ExprKind::OffsetOf { container, fields } => block.and(Rvalue::NullaryOp(
+                NullOp::FieldOffset,
+                Ty::new_field_type(this.tcx, container, fields),
+            )),
 
             ExprKind::Literal { .. }
             | ExprKind::NamedConst { .. }
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -419,7 +419,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
             | Rvalue::NullaryOp(
                 NullOp::SizeOf
                 | NullOp::AlignOf
-                | NullOp::OffsetOf(..)
+                | NullOp::FieldOffset
                 | NullOp::UbChecks
                 | NullOp::ContractChecks,
                 _,
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -481,11 +481,16 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
                 let val = match null_op {
                     NullOp::SizeOf if layout.is_sized() => layout.size.bytes(),
                     NullOp::AlignOf if layout.is_sized() => layout.align.abi.bytes(),
-                    NullOp::OffsetOf(fields) => self
-                        .ecx
-                        .tcx
-                        .offset_of_subfield(self.typing_env, layout, fields.iter())
-                        .bytes(),
+                    NullOp::FieldOffset
+                        if let &ty::Field(container, field_path) = layout.ty.kind()
+                            && let Ok(layout) =
+                                self.tcx.layout_of(self.typing_env.as_query_input(container)) =>
+                    {
+                        self.ecx
+                            .tcx
+                            .offset_of_subfield(self.typing_env, layout, field_path.iter())
+                            .bytes()
+                    }
                     _ => return ValueOrPlace::Value(FlatSet::Top),
                 };
                 FlatSet::Elem(Scalar::from_target_usize(val, &self.tcx))
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
@@ -204,7 +204,7 @@ enum Value<'tcx> {
     Len(VnIndex),
 
     // Operations.
-    NullaryOp(NullOp<'tcx>, Ty<'tcx>),
+    NullaryOp(NullOp, Ty<'tcx>),
     UnaryOp(UnOp, VnIndex),
     BinaryOp(BinOp, VnIndex, VnIndex),
     Cast {
@@ -492,11 +492,18 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 let val = match null_op {
                     NullOp::SizeOf => arg_layout.size.bytes(),
                     NullOp::AlignOf => arg_layout.align.abi.bytes(),
-                    NullOp::OffsetOf(fields) => self
-                        .ecx
-                        .tcx
-                        .offset_of_subfield(self.typing_env(), arg_layout, fields.iter())
-                        .bytes(),
+                    NullOp::FieldOffset => {
+                        let &ty::Field(container, field_path) = arg_ty.kind() else {
+                            bug!(
+                                "FIXME(field_projections): should we really bug here, or return `None`?"
+                            )
+                        };
+                        let layout = self.ecx.layout_of(container).ok()?;
+                        self.ecx
+                            .tcx
+                            .offset_of_subfield(self.typing_env(), layout, field_path.iter())
+                            .bytes()
+                    }
                     NullOp::UbChecks => return None,
                     NullOp::ContractChecks => return None,
                 };
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -625,10 +625,17 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                 let val = match null_op {
                     NullOp::SizeOf => op_layout.size.bytes(),
                     NullOp::AlignOf => op_layout.align.abi.bytes(),
-                    NullOp::OffsetOf(fields) => self
-                        .tcx
-                        .offset_of_subfield(self.typing_env, op_layout, fields.iter())
-                        .bytes(),
+                    NullOp::FieldOffset => {
+                        let &ty::Field(container, field_path) = ty.kind() else {
+                            bug!(
+                                "FIXME(field_projections): should we really bug here, or return `None`?"
+                            )
+                        };
+                        let layout = self.ecx.layout_of(container).ok()?;
+                        self.tcx
+                            .offset_of_subfield(self.typing_env, layout, field_path.iter())
+                            .bytes()
+                    }
                     NullOp::UbChecks => return None,
                     NullOp::ContractChecks => return None,
                 };
diff --git a/compiler/rustc_mir_transform/src/lower_intrinsics.rs b/compiler/rustc_mir_transform/src/lower_intrinsics.rs
@@ -374,6 +374,18 @@ impl<'tcx> crate::MirPass<'tcx> for LowerIntrinsics {
                         ));
                         terminator.kind = TerminatorKind::Goto { target };
                     }
+                    sym::unaligned_field_offset => {
+                        let target = target.unwrap();
+                        let ty = generic_args.type_at(0);
+                        block.statements.push(Statement::new(
+                            terminator.source_info,
+                            StatementKind::Assign(Box::new((
+                                *destination,
+                                Rvalue::NullaryOp(NullOp::FieldOffset, ty),
+                            ))),
+                        ));
+                        terminator.kind = TerminatorKind::Goto { target };
+                    }
                     _ => {}
                 }
             }
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -452,10 +452,13 @@ impl<'tcx> Validator<'_, 'tcx> {
                 self.validate_operand(operand)?;
             }
 
-            Rvalue::NullaryOp(op, _) => match op {
+            Rvalue::NullaryOp(op, ty) => match op {
                 NullOp::SizeOf => {}
                 NullOp::AlignOf => {}
-                NullOp::OffsetOf(_) => {}
+                NullOp::FieldOffset => match ty.kind() {
+                    ty::Field(..) => {}
+                    _ => bug!("FIXME(field_projections): should we report an error here?"),
+                },
                 NullOp::UbChecks => {}
                 NullOp::ContractChecks => {}
             },
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
@@ -1341,14 +1341,17 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     }
                 }
             }
-            Rvalue::NullaryOp(NullOp::OffsetOf(indices), container) => {
+            Rvalue::NullaryOp(NullOp::FieldOffset, ty) => {
+                let ty::Field(container, field_path) = ty.kind() else {
+                    bug!("FIXME(field_projections): report error?")
+                };
                 let fail_out_of_bounds = |this: &mut Self, location, field, ty| {
                     this.fail(location, format!("Out of bounds field {field:?} for {ty}"));
                 };
 
                 let mut current_ty = *container;
 
-                for (variant, field) in indices.iter() {
+                for (variant, field) in field_path.iter() {
                     match current_ty.kind() {
                         ty::Tuple(fields) => {
                             if variant != FIRST_VARIANT {
diff --git a/compiler/rustc_public/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs

Original file line number	Diff line number	Diff line change
`@@ -1624,6 +1624,12 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {`
`1624`	`1624`	`)`
`1625`	`1625`	`.unwrap();`
`1626`	`1626`	`}`
	`1627`	`+ Rvalue::NullaryOp(NullOp::FieldOffset, ty) => match ty.kind() {`
	`1628`	`+ ty::Field(..) => {}`
	`1629`	`+ _ => bug!(`
	`1630`	+ "FIXME(field_projections): should we report an error here, or `span_mirbug!`?"
	`1631`	`+ ),`
	`1632`	`+ },`
`1627`	`1633`
`1628`	`1634`	`Rvalue::Use(_)`
`1629`	`1635`	`\| Rvalue::UnaryOp(_, _)`
`@@ -1632,8 +1638,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {`
`1632`	`1638`	`\| Rvalue::RawPtr(..)`
`1633`	`1639`	`\| Rvalue::ThreadLocalRef(..)`
`1634`	`1640`	`\| Rvalue::Len(..)`
`1635`		`- \| Rvalue::Discriminant(..)`
`1636`		`- \| Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}`
	`1641`	`+ \| Rvalue::Discriminant(..) => {}`
`1637`	`1642`	`}`
`1638`	`1643`	`}`
`1639`	`1644`
Original file line number	Diff line number	Diff line change
`@@ -1072,7 +1072,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {`
`1072`	`1072`	`match op {`
`1073`	`1073`	`NullOp::SizeOf => write!(fmt, "SizeOf({t})"),`
`1074`	`1074`	`NullOp::AlignOf => write!(fmt, "AlignOf({t})"),`
`1075`		`- NullOp::OffsetOf(fields) => write!(fmt, "OffsetOf({t}, {fields:?})"),`
	`1075`	`+ NullOp::FieldOffset => write!(fmt, "FieldOffset({t})"),`
`1076`	`1076`	`NullOp::UbChecks => write!(fmt, "UbChecks()"),`
`1077`	`1077`	`NullOp::ContractChecks => write!(fmt, "ContractChecks()"),`
`1078`	`1078`	`}`
Original file line number	Diff line number	Diff line change
`@@ -751,7 +751,7 @@ impl<'tcx> Rvalue<'tcx> {`
`751`	`751`	`op.ty(tcx, arg_ty)`
`752`	`752`	`}`
`753`	`753`	`Rvalue::Discriminant(ref place) => place.ty(local_decls, tcx).ty.discriminant_ty(tcx),`
`754`		`- Rvalue::NullaryOp(NullOp::SizeOf \| NullOp::AlignOf \| NullOp::OffsetOf(..), _) => {`
	`754`	`+ Rvalue::NullaryOp(NullOp::SizeOf \| NullOp::AlignOf \| NullOp::FieldOffset, _) => {`
`755`	`755`	`tcx.types.usize`
`756`	`756`	`}`
`757`	`757`	`Rvalue::NullaryOp(NullOp::ContractChecks, _)`
`@@ -819,10 +819,10 @@ impl BorrowKind {`
`819`	`819`	`}`
`820`	`820`	`}`
`821`	`821`
`822`		`-impl<'tcx> NullOp<'tcx> {`
`823`		`- pub fn ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {`
	`822`	`+impl NullOp {`
	`823`	`+ pub fn ty<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {`
`824`	`824`	`match self {`
`825`		`- NullOp::SizeOf \| NullOp::AlignOf \| NullOp::OffsetOf(_) => tcx.types.usize,`
	`825`	`+ NullOp::SizeOf \| NullOp::AlignOf \| NullOp::FieldOffset => tcx.types.usize,`
`826`	`826`	`NullOp::UbChecks \| NullOp::ContractChecks => tcx.types.bool,`
`827`	`827`	`}`
`828`	`828`	`}`