Use !null pattern type in libcore

Use `!null` pattern type in libcore

Author: oli-obk

compiler/rustc_const_eval/src/interpret/visitor.rs

@@ -137,7 +137,12 @@ pub trait ValueVisitor<'tcx, M: Machine<'tcx>>: Sized {
 
                 // ... that contains a `NonNull`... (gladly, only a single field here)
                 assert_eq!(nonnull_ptr.layout().fields.count(), 1);
-                let raw_ptr = self.ecx().project_field(&nonnull_ptr, FieldIdx::ZERO)?; // the actual raw ptr
+                let pat_ty = self.ecx().project_field(&nonnull_ptr, FieldIdx::ZERO)?; // `*mut T is !null`
+                let base = match *pat_ty.layout().ty.kind() {
+                    ty::Pat(base, _) => self.ecx().layout_of(base)?,
+                    _ => unreachable!(),
+                };
+                let raw_ptr = pat_ty.transmute(base, self.ecx())?; // The actual raw pointer
 
                 // ... whose only field finally is a raw ptr we can dereference.
                 self.visit_box(ty, &raw_ptr)?;

compiler/rustc_mir_transform/src/elaborate_box_derefs.rs

@@ -10,7 +10,7 @@ use rustc_index::{IndexVec, indexvec};
 use rustc_middle::mir::visit::MutVisitor;
 use rustc_middle::mir::*;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty::{self, PatternKind, Ty, TyCtxt};
 
 use crate::patch::MirPatch;
 
@@ -20,21 +20,27 @@ fn build_ptr_tys<'tcx>(
     pointee: Ty<'tcx>,
     unique_def: ty::AdtDef<'tcx>,
     nonnull_def: ty::AdtDef<'tcx>,
-) -> (Ty<'tcx>, Ty<'tcx>, Ty<'tcx>) {
+) -> (Ty<'tcx>, Ty<'tcx>, Ty<'tcx>, Ty<'tcx>) {
     let args = tcx.mk_args(&[pointee.into()]);
     let unique_ty = Ty::new_adt(tcx, unique_def, args);
     let nonnull_ty = Ty::new_adt(tcx, nonnull_def, args);
     let ptr_ty = Ty::new_imm_ptr(tcx, pointee);
+    let pat_ty = Ty::new_pat(tcx, ptr_ty, tcx.mk_pat(PatternKind::NotNull));
 
-    (unique_ty, nonnull_ty, ptr_ty)
+    (unique_ty, nonnull_ty, pat_ty, ptr_ty)
 }
 
 /// Constructs the projection needed to access a Box's pointer
 pub(super) fn build_projection<'tcx>(
     unique_ty: Ty<'tcx>,
     nonnull_ty: Ty<'tcx>,
-) -> [PlaceElem<'tcx>; 2] {
-    [PlaceElem::Field(FieldIdx::ZERO, unique_ty), PlaceElem::Field(FieldIdx::ZERO, nonnull_ty)]
+    pat_ty: Ty<'tcx>,
+) -> [PlaceElem<'tcx>; 3] {
+    [
+        PlaceElem::Field(FieldIdx::ZERO, unique_ty),
+        PlaceElem::Field(FieldIdx::ZERO, nonnull_ty),
+        PlaceElem::Field(FieldIdx::ZERO, pat_ty),
+    ]
 }
 
 struct ElaborateBoxDerefVisitor<'a, 'tcx> {
@@ -66,7 +72,7 @@ impl<'a, 'tcx> MutVisitor<'tcx> for ElaborateBoxDerefVisitor<'a, 'tcx> {
         {
             let source_info = self.local_decls[place.local].source_info;
 
-            let (unique_ty, nonnull_ty, ptr_ty) =
+            let (unique_ty, nonnull_ty, pat_ty, ptr_ty) =
                 build_ptr_tys(tcx, boxed_ty, self.unique_def, self.nonnull_def);
 
             let ptr_local = self.patch.new_temp(ptr_ty, source_info.span);
@@ -78,7 +84,7 @@ impl<'a, 'tcx> MutVisitor<'tcx> for ElaborateBoxDerefVisitor<'a, 'tcx> {
                     CastKind::Transmute,
                     Operand::Copy(
                         Place::from(place.local)
-                            .project_deeper(&build_projection(unique_ty, nonnull_ty), tcx),
+                            .project_deeper(&build_projection(unique_ty, nonnull_ty, pat_ty), tcx),
                     ),
                     ptr_ty,
                 ),
@@ -101,7 +107,7 @@ impl<'a, 'tcx> MutVisitor<'tcx> for ElaborateBoxDerefVisitor<'a, 'tcx> {
             && let ty::Adt(box_adt, box_args) = Ty::new_box(tcx, pointee).kind()
         {
             let args = tcx.mk_args(&[pointee.into()]);
-            let (unique_ty, nonnull_ty, ptr_ty) =
+            let (unique_ty, nonnull_ty, pat_ty, ptr_ty) =
                 build_ptr_tys(tcx, pointee, self.unique_def, self.nonnull_def);
             let adt_kind = |def: ty::AdtDef<'tcx>, args| {
                 Box::new(AggregateKind::Adt(def.did(), VariantIdx::ZERO, args, None, None))
@@ -121,13 +127,20 @@ impl<'a, 'tcx> MutVisitor<'tcx> for ElaborateBoxDerefVisitor<'a, 'tcx> {
                 Rvalue::Cast(CastKind::Transmute, mutptr_to_u8.clone(), ptr_ty),
             );
 
+            let pat_ptr = self.patch.new_temp(pat_ty, source_info.span);
+            self.patch.add_assign(
+                location,
+                pat_ptr.into(),
+                Rvalue::Cast(CastKind::Transmute, Operand::Move(constptr.into()), pat_ty),
+            );
+
             let nonnull = self.patch.new_temp(nonnull_ty, source_info.span);
             self.patch.add_assign(
                 location,
                 nonnull.into(),
                 Rvalue::Aggregate(
                     adt_kind(self.nonnull_def, args),
-                    indexvec![Operand::Move(constptr.into())],
+                    indexvec![Operand::Move(pat_ptr.into())],
                 ),
             );
 
@@ -199,10 +212,11 @@ impl<'tcx> crate::MirPass<'tcx> for ElaborateBoxDerefs {
                         let new_projections =
                             new_projections.get_or_insert_with(|| base.projection.to_vec());
 
-                        let (unique_ty, nonnull_ty, ptr_ty) =
+                        let (unique_ty, nonnull_ty, pat_ty, ptr_ty) =
                             build_ptr_tys(tcx, boxed_ty, unique_def, nonnull_def);
 
-                        new_projections.extend_from_slice(&build_projection(unique_ty, nonnull_ty));
+                        new_projections
+                            .extend_from_slice(&build_projection(unique_ty, nonnull_ty, pat_ty));
                         // While we can't project into `NonNull<_>` in a basic block
                         // due to MCP#807, this is debug info where it's fine.
                         new_projections.push(PlaceElem::Field(FieldIdx::ZERO, ptr_ty));

compiler/rustc_mir_transform/src/validate.rs

@@ -669,24 +669,25 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 let fail_out_of_bounds = |this: &mut Self, location| {
                     this.fail(location, format!("Out of bounds field {f:?} for {parent_ty:?}"));
                 };
+
+                let kind = match parent_ty.ty.kind() {
+                    &ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => {
+                        self.tcx.type_of(def_id).instantiate(self.tcx, args).kind()
+                    }
+                    kind => kind,
+                };
+
                 let check_equal = |this: &mut Self, location, f_ty| {
                     if !this.mir_assign_valid_types(ty, f_ty) {
                         this.fail(
                             location,
                             format!(
-                                "Field projection `{place_ref:?}.{f:?}` specified type `{ty}`, but actual type is `{f_ty}`"
+                                "Field projection `{place_ref:?}.{f:?}` specified type `{ty}`, but actual field type of `{kind:?}` is `{f_ty}`"
                             )
                         )
                     }
                 };
 
-                let kind = match parent_ty.ty.kind() {
-                    &ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => {
-                        self.tcx.type_of(def_id).instantiate(self.tcx, args).kind()
-                    }
-                    kind => kind,
-                };
-
                 match kind {
                     ty::Tuple(fields) => {
                         let Some(f_ty) = fields.get(f.as_usize()) else {

library/core/src/ptr/non_null.rs

@@ -1,6 +1,6 @@
 use crate::cmp::Ordering;
 use crate::marker::{Destruct, PointeeSized, Unsize};
-use crate::mem::{MaybeUninit, SizedTypeProperties};
+use crate::mem::{MaybeUninit, SizedTypeProperties, transmute};
 use crate::num::NonZero;
 use crate::ops::{CoerceUnsized, DispatchFromDyn};
 use crate::pin::PinCoerceUnsized;
@@ -69,13 +69,10 @@ use crate::{fmt, hash, intrinsics, mem, ptr};
 /// [null pointer optimization]: crate::option#representation
 #[stable(feature = "nonnull", since = "1.25.0")]
 #[repr(transparent)]
-#[rustc_layout_scalar_valid_range_start(1)]
 #[rustc_nonnull_optimization_guaranteed]
 #[rustc_diagnostic_item = "NonNull"]
 pub struct NonNull<T: PointeeSized> {
-    // Remember to use `.as_ptr()` instead of `.pointer`, as field projecting to
-    // this is banned by <https://github.com/rust-lang/compiler-team/issues/807>.
-    pointer: *const T,
+    pointer: crate::pattern_type!(*const T is !null),
 }
 
 /// `NonNull` pointers are not `Send` because the data they reference may be aliased.
@@ -99,9 +96,9 @@ impl<T: Sized> NonNull<T> {
     #[must_use]
     #[inline]
     pub const fn without_provenance(addr: NonZero<usize>) -> Self {
-        let pointer = crate::ptr::without_provenance(addr.get());
+        let pointer: *const T = crate::ptr::without_provenance(addr.get());
         // SAFETY: we know `addr` is non-zero.
-        unsafe { NonNull { pointer } }
+        unsafe { NonNull { pointer: transmute(pointer) } }
     }
 
     /// Creates a new `NonNull` that is dangling, but well-aligned.
@@ -238,7 +235,7 @@ impl<T: PointeeSized> NonNull<T> {
                 "NonNull::new_unchecked requires that the pointer is non-null",
                 (ptr: *mut () = ptr as *mut ()) => !ptr.is_null()
             );
-            NonNull { pointer: ptr as _ }
+            NonNull { pointer: transmute(ptr) }
         }
     }
 
@@ -281,7 +278,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn from_ref(r: &T) -> Self {
         // SAFETY: A reference cannot be null.
-        unsafe { NonNull { pointer: r as *const T } }
+        unsafe { NonNull { pointer: transmute(r as *const T) } }
     }
 
     /// Converts a mutable reference to a `NonNull` pointer.
@@ -290,7 +287,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn from_mut(r: &mut T) -> Self {
         // SAFETY: A mutable reference cannot be null.
-        unsafe { NonNull { pointer: r as *mut T } }
+        unsafe { NonNull { pointer: transmute(r as *mut T) } }
     }
 
     /// Performs the same functionality as [`std::ptr::from_raw_parts`], except that a
@@ -501,7 +498,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn cast<U>(self) -> NonNull<U> {
         // SAFETY: `self` is a `NonNull` pointer which is necessarily non-null
-        unsafe { NonNull { pointer: self.as_ptr() as *mut U } }
+        unsafe { NonNull { pointer: transmute(self.as_ptr() as *mut U) } }
     }
 
     /// Try to cast to a pointer of another type by checking alignment.
@@ -580,7 +577,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: intrinsics::offset(self.as_ptr(), count) } }
+        unsafe { NonNull { pointer: transmute(intrinsics::offset(self.as_ptr(), count)) } }
     }
 
     /// Calculates the offset from a pointer in bytes.
@@ -604,7 +601,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_offset(count) } }
+        unsafe { NonNull { pointer: transmute(self.as_ptr().byte_offset(count)) } }
     }
 
     /// Adds an offset to a pointer (convenience for `.offset(count as isize)`).
@@ -656,7 +653,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: intrinsics::offset(self.as_ptr(), count) } }
+        unsafe { NonNull { pointer: transmute(intrinsics::offset(self.as_ptr(), count)) } }
     }
 
     /// Calculates the offset from a pointer in bytes (convenience for `.byte_offset(count as isize)`).
@@ -680,7 +677,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `add` guarantees that the resulting pointer is pointing
         // to an allocation, there can't be an allocation at null, thus it's safe to construct
         // `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_add(count) } }
+        unsafe { NonNull { pointer: transmute(self.as_ptr().byte_add(count)) } }
     }
 
     /// Subtracts an offset from a pointer (convenience for
@@ -762,7 +759,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `sub` guarantees that the resulting pointer is pointing
         // to an allocation, there can't be an allocation at null, thus it's safe to construct
         // `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_sub(count) } }
+        unsafe { NonNull { pointer: transmute(self.as_ptr().byte_sub(count)) } }
     }
 
     /// Calculates the distance between two pointers within the same allocation. The returned value is in

library/std/src/os/unix/io/tests.rs

@@ -2,8 +2,7 @@ use crate::os::unix::io::RawFd;
 
 #[test]
 fn test_raw_fd_layout() {
-    // `OwnedFd` and `BorrowedFd` use `rustc_layout_scalar_valid_range_start`
-    // and `rustc_layout_scalar_valid_range_end`, with values that depend on
+    // `OwnedFd` and `BorrowedFd` use pattern types, with ranges that depend on
     // the bit width of `RawFd`. If this ever changes, those values will need
     // to be updated.
     assert_eq!(size_of::<RawFd>(), 4);

library/std/src/os/wasi/io/tests.rs

@@ -2,8 +2,7 @@ use crate::os::wasi::io::RawFd;
 
 #[test]
 fn test_raw_fd_layout() {
-    // `OwnedFd` and `BorrowedFd` use `rustc_layout_scalar_valid_range_start`
-    // and `rustc_layout_scalar_valid_range_end`, with values that depend on
+    // `OwnedFd` and `BorrowedFd` use pattern types with ranges that depend on
     // the bit width of `RawFd`. If this ever changes, those values will need
     // to be updated.
     assert_eq!(size_of::<RawFd>(), 4);

src/tools/clippy/clippy_lints/src/transmute/transmute_undefined_repr.rs

@@ -242,6 +242,10 @@ fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx>
     loop {
         ty = cx.tcx.try_normalize_erasing_regions(cx.typing_env(), ty).unwrap_or(ty);
         return match *ty.kind() {
+            ty::Pat(base, _) => {
+                ty = base;
+                continue;
+            },
             ty::Array(sub_ty, _) if matches!(sub_ty.kind(), ty::Int(_) | ty::Uint(_)) => {
                 ReducedTy::TypeErasure { raw_ptr_only: false }
             },

tests/codegen-llvm/loads.rs

@@ -58,7 +58,7 @@ pub fn load_raw_pointer<'a>(x: &*const i32) -> *const i32 {
 // CHECK-LABEL: @load_box
 #[no_mangle]
 pub fn load_box<'a>(x: Box<Box<i32>>) -> Box<i32> {
-    // CHECK: load ptr, ptr %{{.*}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META]], !noundef !{{[0-9]+}}
+    // CHECK: load ptr, ptr %{{.*}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !noundef !{{[0-9]+}}
     *x
 }
 

tests/mir-opt/box_expr.rs

@@ -7,10 +7,11 @@
 fn main() {
     // CHECK-LABEL: fn main(
     // CHECK:   [[ptr:_.*]] = move {{_.*}} as *const S (Transmute);
-    // CHECK:   [[nonnull:_.*]] = NonNull::<S> { pointer: move [[ptr]] };
+    // CHECK:   [[pat_ptr:_.*]] = move [[ptr]] as (*const S) is !null (Transmute);
+    // CHECK:   [[nonnull:_.*]] = NonNull::<S> { pointer: move [[pat_ptr]] };
     // CHECK:   [[unique:_.*]] = Unique::<S> { pointer: move [[nonnull]], _marker: const PhantomData::<S> };
     // CHECK:   [[box:_.*]] = Box::<S>(move [[unique]], const std::alloc::Global);
-    // CHECK:   [[ptr:_.*]] = copy (([[box]].0: std::ptr::Unique<S>).0: std::ptr::NonNull<S>) as *const S (Transmute);
+    // CHECK:   [[ptr:_.*]] = copy ((([[box]].0: std::ptr::Unique<S>).0: std::ptr::NonNull<S>).0: (*const S) is !null) as *const S (Transmute);
     // CHECK:   (*[[ptr]]) = S::new() -> [return: [[ret:bb.*]], unwind: [[unwind:bb.*]]];
     // CHECK: [[ret]]: {
     // CHECK:   [[box2:_.*]] = move [[box]];

tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff

@@ -9,10 +9,11 @@
       let mut _4: *mut u8;
       let mut _5: std::boxed::Box<i32>;
       let mut _6: *const i32;
-      let mut _7: std::ptr::NonNull<i32>;
-      let mut _8: std::ptr::Unique<i32>;
-      let mut _9: *const i32;
+      let mut _7: (*const i32) is !null;
+      let mut _8: std::ptr::NonNull<i32>;
+      let mut _9: std::ptr::Unique<i32>;
       let mut _10: *const i32;
+      let mut _11: *const i32;
       scope 1 {
           debug x => _1;
       }
@@ -28,20 +29,20 @@
       bb1: {
           StorageLive(_5);
 -         _6 = move _4 as *const i32 (Transmute);
--         _7 = NonNull::<i32> { pointer: move _6 };
--         _8 = Unique::<i32> { pointer: move _7, _marker: const PhantomData::<i32> };
+-         _7 = move _6 as (*const i32) is !null (Transmute);
+-         _8 = NonNull::<i32> { pointer: move _7 };
 +         _6 = copy _4 as *const i32 (PtrToPtr);
-+         _7 = NonNull::<i32> { pointer: copy _6 };
-+         _8 = Unique::<i32> { pointer: copy _7, _marker: const PhantomData::<i32> };
-          _5 = Box::<i32>(move _8, const std::alloc::Global);
--         _9 = copy ((_5.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>) as *const i32 (Transmute);
--         (*_9) = const 42_i32;
-+         _9 = copy _6;
-+         (*_6) = const 42_i32;
++         _7 = copy _4 as (*const i32) is !null (Transmute);
++         _8 = NonNull::<i32> { pointer: copy _7 };
+          _9 = Unique::<i32> { pointer: move _8, _marker: const PhantomData::<i32> };
+          _5 = Box::<i32>(move _9, const std::alloc::Global);
+-         _10 = copy (((_5.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: (*const i32) is !null) as *const i32 (Transmute);
++         _10 = copy _7 as *const i32 (Transmute);
+          (*_10) = const 42_i32;
           _3 = move _5;
           StorageDead(_5);
-          _10 = copy ((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>) as *const i32 (Transmute);
-          _2 = copy (*_10);
+          _11 = copy (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: (*const i32) is !null) as *const i32 (Transmute);
+          _2 = copy (*_11);
 -         _1 = Add(move _2, const 0_i32);
 -         StorageDead(_2);
 +         _1 = copy _2;