core::mem::Alignemnt: rename as_nonzero to as_nonzero_usize

Author: GrigorenkoPV

compiler/rustc_data_structures/src/tagged_ptr.rs

@@ -55,7 +55,12 @@ pub unsafe trait Tag: Copy {
 /// Returns the number of bits available for use for tags in a pointer to `T`
 /// (this is based on `T`'s alignment).
 pub const fn bits_for<T: ?Sized + Aligned>() -> u32 {
-    crate::aligned::align_of::<T>().as_nonzero().trailing_zeros()
+    let alignment = crate::aligned::align_of::<T>();
+    #[cfg(bootstrap)]
+    let alignment = alignment.as_nonzero();
+    #[cfg(not(bootstrap))]
+    let alignment = alignment.as_nonzero_usize();
+    alignment.trailing_zeros()
 }
 
 /// Returns the correct [`Tag::BITS`] constant for a set of tag values.

library/alloc/src/raw_vec/mod.rs

@@ -570,7 +570,7 @@ const impl<A: [const] Allocator + [const] Destruct> RawVecInner<A> {
 impl<A: Allocator> RawVecInner<A> {
     #[inline]
     const fn new_in(alloc: A, align: Alignment) -> Self {
-        let ptr = Unique::from_non_null(NonNull::without_provenance(align.as_nonzero()));
+        let ptr = Unique::from_non_null(NonNull::without_provenance(align.as_nonzero_usize()));
         // `cap: 0` means "unallocated". zero-sized types are ignored.
         Self { ptr, cap: ZERO_CAP, alloc }
     }

library/core/src/alloc/layout.rs

@@ -268,7 +268,7 @@ impl Layout {
     #[must_use]
     #[inline]
     pub const fn dangling_ptr(&self) -> NonNull<u8> {
-        NonNull::without_provenance(self.align.as_nonzero())
+        NonNull::without_provenance(self.align.as_nonzero_usize())
     }
 
     /// Creates a layout describing the record that can hold a value

library/core/src/mem/alignment.rs

@@ -168,16 +168,28 @@ impl Alignment {
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
     pub const fn as_usize(self) -> usize {
-        // Going through `as_nonzero` helps this be more clearly the inverse of
+        // Going through `as_nonzero_usize` helps this be more clearly the inverse of
         // `new_unchecked`, letting MIR optimizations fold it away.
 
-        self.as_nonzero().get()
+        self.as_nonzero_usize().get()
     }
 
     /// Returns the alignment as a <code>[NonZero]<[usize]></code>.
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
+    #[deprecated(
+        since = "CURRENT_RUSTC_VERSION",
+        note = "renamed to `as_nonzero_usize`",
+        suggestion = "as_nonzero_usize"
+    )]
     #[inline]
     pub const fn as_nonzero(self) -> NonZero<usize> {
+        self.as_nonzero_usize()
+    }
+
+    /// Returns the alignment as a <code>[NonZero]<[usize]></code>.
+    #[unstable(feature = "ptr_alignment_type", issue = "102070")]
+    #[inline]
+    pub const fn as_nonzero_usize(self) -> NonZero<usize> {
         // This transmutes directly to avoid the UbCheck in `NonZero::new_unchecked`
         // since there's no way for the user to trip that check anyway -- the
         // validity invariant of the type would have to have been broken earlier --
@@ -203,7 +215,7 @@ impl Alignment {
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
     pub const fn log2(self) -> u32 {
-        self.as_nonzero().trailing_zeros()
+        self.as_nonzero_usize().trailing_zeros()
     }
 
     /// Returns a bit mask that can be used to match this alignment.
@@ -246,7 +258,7 @@ impl Alignment {
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
 impl fmt::Debug for Alignment {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?} (1 << {:?})", self.as_nonzero(), self.log2())
+        write!(f, "{:?} (1 << {:?})", self.as_nonzero_usize(), self.log2())
     }
 }
 
@@ -277,7 +289,7 @@ impl const TryFrom<usize> for Alignment {
 impl const From<Alignment> for NonZero<usize> {
     #[inline]
     fn from(align: Alignment) -> NonZero<usize> {
-        align.as_nonzero()
+        align.as_nonzero_usize()
     }
 }
 
@@ -294,7 +306,7 @@ impl const From<Alignment> for usize {
 impl cmp::Ord for Alignment {
     #[inline]
     fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.as_nonzero().cmp(&other.as_nonzero())
+        self.as_nonzero_usize().cmp(&other.as_nonzero_usize())
     }
 }
 
@@ -310,7 +322,7 @@ impl cmp::PartialOrd for Alignment {
 impl hash::Hash for Alignment {
     #[inline]
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        self.as_nonzero().hash(state)
+        self.as_nonzero_usize().hash(state)
     }
 }
 

library/core/src/ptr/non_null.rs

@@ -129,7 +129,7 @@ impl<T: Sized> NonNull<T> {
     #[inline]
     pub const fn dangling() -> Self {
         let align = crate::mem::Alignment::of::<T>();
-        NonNull::without_provenance(align.as_nonzero())
+        NonNull::without_provenance(align.as_nonzero_usize())
     }
 
     /// Converts an address back to a mutable pointer, picking up some previously 'exposed'

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff

@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-unwind.diff

@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-abort.diff

@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.64bit.panic-unwind.diff

@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff

@@ -17,7 +17,7 @@
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
                   scope 6 {
-                      scope 8 (inlined std::mem::Alignment::as_nonzero) {
+                      scope 8 (inlined std::mem::Alignment::as_nonzero_usize) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
                       }