Add contracts for all functions in Alignment

library/core/src/intrinsics/mod.rs

@@ -2605,6 +2605,7 @@ pub const fn contract_checks() -> bool {
 // doesn't honor `#[allow_internal_unstable]`, so for the const feature gate we use the user-facing
 // `contracts` feature rather than the perma-unstable `contracts_internals`
 #[rustc_const_unstable(feature = "contracts", issue = "128044")]
+#[miri::intrinsic_fallback_is_spec]
 #[lang = "contract_check_requires"]
 #[rustc_intrinsic]
 pub const fn contract_check_requires<C: Fn() -> bool + Copy>(cond: C) {
@@ -2632,6 +2633,7 @@ pub const fn contract_check_requires<C: Fn() -> bool + Copy>(cond: C) {
 // `contracts` feature rather than the perma-unstable `contracts_internals`.
 // Const-checking doesn't honor allow_internal_unstable logic used by contract expansion.
 #[rustc_const_unstable(feature = "contracts", issue = "128044")]
+#[miri::intrinsic_fallback_is_spec]
 #[lang = "contract_check_ensures"]
 #[rustc_intrinsic]
 pub const fn contract_check_ensures<C: Fn(&Ret) -> bool + Copy, Ret>(cond: C, ret: Ret) -> Ret {

library/core/src/lib.rs

@@ -106,6 +106,7 @@
 #![feature(const_cmp)]
 #![feature(const_destruct)]
 #![feature(const_eval_select)]
+#![feature(contracts)]
 #![feature(core_intrinsics)]
 #![feature(coverage_attribute)]
 #![feature(disjoint_bitor)]

library/core/src/mem/mod.rs

@@ -506,6 +506,8 @@ pub const fn align_of<T>() -> usize {
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_stable(feature = "const_align_of_val", since = "1.85.0")]
+#[rustc_allow_const_fn_unstable(contracts)]
+#[core::contracts::ensures(|result: &usize| result.is_power_of_two())]
 pub const fn align_of_val<T: ?Sized>(val: &T) -> usize {
     // SAFETY: val is a reference, so it's a valid raw pointer
     unsafe { intrinsics::align_of_val(val) }

library/core/src/ptr/alignment.rs

@@ -45,6 +45,8 @@ impl Alignment {
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
     #[must_use]
+    #[rustc_allow_const_fn_unstable(contracts)]
+    #[core::contracts::ensures(|result: &Alignment| result.as_usize().is_power_of_two())]
     pub const fn of<T>() -> Self {
         // This can't actually panic since type alignment is always a power of two.
         const { Alignment::new(align_of::<T>()).unwrap() }
@@ -56,6 +58,11 @@ impl Alignment {
     /// Note that `0` is not a power of two, nor a valid alignment.
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
+    #[rustc_allow_const_fn_unstable(contracts)]
+    #[core::contracts::ensures(
+        move |result: &Option<Alignment>|
+        align.is_power_of_two() == result.is_some() &&
+        (result.is_none() || result.unwrap().as_usize() == align))]
     pub const fn new(align: usize) -> Option<Self> {
         if align.is_power_of_two() {
             // SAFETY: Just checked it only has one bit set
@@ -76,6 +83,12 @@ impl Alignment {
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
     #[track_caller]
+    #[rustc_allow_const_fn_unstable(contracts)]
+    #[allow(unused_parens)]
+    #[core::contracts::requires(align.is_power_of_two())]
+    #[core::contracts::ensures(
+        move |result: &Alignment|
+        result.as_usize() == align && result.as_usize().is_power_of_two())]
     pub const unsafe fn new_unchecked(align: usize) -> Self {
         assert_unsafe_precondition!(
             check_language_ub,
@@ -91,13 +104,19 @@ impl Alignment {
     /// Returns the alignment as a [`usize`].
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
+    #[rustc_allow_const_fn_unstable(contracts)]
+    #[core::contracts::ensures(|result: &usize| result.is_power_of_two())]
     pub const fn as_usize(self) -> usize {
         self.0 as usize
     }
 
     /// Returns the alignment as a <code>[NonZero]<[usize]></code>.
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
+    #[rustc_allow_const_fn_unstable(contracts)]
+    #[core::contracts::ensures(
+        move |result: &NonZero<usize>|
+        result.get().is_power_of_two() && result.get() == self.as_usize())]
     pub const fn as_nonzero(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
@@ -123,6 +142,12 @@ impl Alignment {
     /// ```
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
+    #[rustc_const_unstable(feature = "contracts", issue = "128044")]
+    #[allow(unused_parens)]
+    #[core::contracts::requires(self.as_usize().is_power_of_two())]
+    #[core::contracts::ensures(
+        move |result: &u32|
+        *result < usize::BITS && (1usize << *result) == self.as_usize())]
     pub const fn log2(self) -> u32 {
         self.as_nonzero().trailing_zeros()
     }
@@ -152,6 +177,11 @@ impl Alignment {
     /// ```
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
+    #[rustc_const_unstable(feature = "contracts", issue = "128044")]
+    #[core::contracts::ensures(
+        move |result: &usize|
+        *result > 0 && *result == !(self.as_usize() -1) &&
+        self.as_usize() & *result == self.as_usize())]
     pub const fn mask(self) -> usize {
         // SAFETY: The alignment is always nonzero, and therefore decrementing won't overflow.
         !(unsafe { self.as_usize().unchecked_sub(1) })

src/tools/miri/tests/pass/shims/time-with-isolation.rs

@@ -27,7 +27,7 @@ fn test_time_passes() {
     // if `NANOSECONDS_PER_BASIC_BLOCK` changes. It may also need updating if the standard library
     // code that runs in the loop above changes.
     assert!(diff.as_millis() > 5);
-    assert!(diff.as_millis() < 20);
+    assert!(diff.as_millis() < 25);
 }
 
 fn test_block_for_one_second() {

tests/codegen-llvm/cross-crate-inlining/auxiliary/leaf.rs

@@ -4,8 +4,8 @@
 
 // This function *looks* like it contains a call, but that call will be optimized out by MIR
 // optimizations.
-pub fn leaf_fn() -> String {
-    String::new()
+pub fn leaf_fn() -> bool {
+    Some(0).is_some()
 }
 
 // This function contains a call, even after MIR optimizations. It is only eligible for

tests/codegen-llvm/cross-crate-inlining/leaf-inlining.rs

@@ -7,7 +7,7 @@ extern crate leaf;
 
 // Check that we inline a leaf cross-crate call
 #[no_mangle]
-pub fn leaf_outer() -> String {
+pub fn leaf_outer() -> bool {
     // CHECK-NOT: call {{.*}}leaf_fn
     leaf::leaf_fn()
 }

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

@@ -16,23 +16,34 @@
           scope 4 (inlined Unique::<[bool; 0]>::dangling) {
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
-                  let mut _6: std::num::NonZero<usize>;
+                  let _6: std::ptr::Alignment;
+                  let mut _7: std::num::NonZero<usize>;
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 10 (inlined std::ptr::Alignment::as_nonzero) {
+                          let mut _8: {closure@std::ptr::Alignment::as_nonzero::{closure#0}};
+                          let mut _9: std::num::NonZero<usize>;
+                          scope 11 {
+                          }
+                          scope 12 (inlined core::contracts::build_check_ensures::<NonZero<usize>, {closure@std::ptr::Alignment::as_nonzero::{closure#0}}>) {
+                          }
                       }
-                      scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
-                          let _7: *const [bool; 0];
-                          scope 10 {
+                      scope 13 (inlined NonNull::<[bool; 0]>::without_provenance) {
+                          let _10: *const [bool; 0];
+                          scope 14 {
                           }
-                          scope 11 (inlined NonZero::<usize>::get) {
+                          scope 15 (inlined NonZero::<usize>::get) {
                           }
-                          scope 12 (inlined std::ptr::without_provenance::<[bool; 0]>) {
-                              scope 13 (inlined without_provenance_mut::<[bool; 0]>) {
+                          scope 16 (inlined std::ptr::without_provenance::<[bool; 0]>) {
+                              scope 17 (inlined without_provenance_mut::<[bool; 0]>) {
                               }
                           }
                       }
                   }
                   scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                      scope 8 {
+                      }
+                      scope 9 (inlined core::contracts::build_check_ensures::<std::ptr::Alignment, {closure@std::ptr::Alignment::of<[bool; 0]>::{closure#0}}>) {
+                      }
                   }
               }
           }
@@ -45,33 +56,42 @@
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
-          _6 = const NonZero::<usize>(core::num::niche_types::NonZeroUsizeInner(1_usize));
+          _6 = contract_check_ensures::<{closure@std::ptr::Alignment::of<[bool; 0]>::{closure#0}}, std::ptr::Alignment>(const ZeroSized: {closure@std::ptr::Alignment::of<[bool; 0]>::{closure#0}}, const std::ptr::Alignment::of::<[bool; 0]>::{constant#0}) -> [return: bb2, unwind unreachable];
+      }
+
+      bb1: {
+          StorageDead(_1);
+          return;
+      }
+
+      bb2: {
           StorageLive(_7);
-          _7 = const {0x1 as *const [bool; 0]};
-          _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};
+          StorageLive(_8);
+          _8 = {closure@$SRC_DIR/core/src/ptr/alignment.rs:LL:COL} { 0: copy _6 };
+          StorageLive(_9);
+          _9 = copy _6 as std::num::NonZero<usize> (Transmute);
+          _7 = contract_check_ensures::<{closure@std::ptr::Alignment::as_nonzero::{closure#0}}, NonZero<usize>>(move _8, move _9) -> [return: bb3, unwind unreachable];
+      }
+
+      bb3: {
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_10);
+          _10 = copy _7 as *const [bool; 0] (Transmute);
+          _5 = NonNull::<[bool; 0]> { pointer: copy _10 };
+          StorageDead(_10);
           StorageDead(_7);
           StorageDead(_6);
-          _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }};
+          _4 = Unique::<[bool; 0]> { pointer: move _5, _marker: const PhantomData::<[bool; 0]> };
           StorageDead(_5);
-          _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }};
+          _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize, Implicit));
           StorageDead(_4);
-          _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global);
+          _2 = Box::<[bool]>(copy _3, const std::alloc::Global);
           StorageDead(_3);
-          _1 = const A {{ foo: Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC2, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }};
+          _1 = A { foo: move _2 };
           StorageDead(_2);
           _0 = const ();
           drop(_1) -> [return: bb1, unwind unreachable];
       }
-
-      bb1: {
-          StorageDead(_1);
-          return;
-      }
   }
 
-  ALLOC2 (size: 8, align: 4) { .. }
-
-  ALLOC1 (size: 8, align: 4) { .. }
-
-  ALLOC0 (size: 8, align: 4) { .. }
-

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

@@ -16,23 +16,34 @@
           scope 4 (inlined Unique::<[bool; 0]>::dangling) {
               let mut _5: std::ptr::NonNull<[bool; 0]>;
               scope 5 (inlined NonNull::<[bool; 0]>::dangling) {
-                  let mut _6: std::num::NonZero<usize>;
+                  let _6: std::ptr::Alignment;
+                  let mut _7: std::num::NonZero<usize>;
                   scope 6 {
-                      scope 8 (inlined std::ptr::Alignment::as_nonzero) {
+                      scope 10 (inlined std::ptr::Alignment::as_nonzero) {
+                          let mut _8: {closure@std::ptr::Alignment::as_nonzero::{closure#0}};
+                          let mut _9: std::num::NonZero<usize>;
+                          scope 11 {
+                          }
+                          scope 12 (inlined core::contracts::build_check_ensures::<NonZero<usize>, {closure@std::ptr::Alignment::as_nonzero::{closure#0}}>) {
+                          }
                       }
-                      scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
-                          let _7: *const [bool; 0];
-                          scope 10 {
+                      scope 13 (inlined NonNull::<[bool; 0]>::without_provenance) {
+                          let _10: *const [bool; 0];
+                          scope 14 {
                           }
-                          scope 11 (inlined NonZero::<usize>::get) {
+                          scope 15 (inlined NonZero::<usize>::get) {
                           }
-                          scope 12 (inlined std::ptr::without_provenance::<[bool; 0]>) {
-                              scope 13 (inlined without_provenance_mut::<[bool; 0]>) {
+                          scope 16 (inlined std::ptr::without_provenance::<[bool; 0]>) {
+                              scope 17 (inlined without_provenance_mut::<[bool; 0]>) {
                               }
                           }
                       }
                   }
                   scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
+                      scope 8 {
+                      }
+                      scope 9 (inlined core::contracts::build_check_ensures::<std::ptr::Alignment, {closure@std::ptr::Alignment::of<[bool; 0]>::{closure#0}}>) {
+                      }
                   }
               }
           }
@@ -45,22 +56,7 @@
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
-          _6 = const NonZero::<usize>(core::num::niche_types::NonZeroUsizeInner(1_usize));
-          StorageLive(_7);
-          _7 = const {0x1 as *const [bool; 0]};
-          _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};
-          StorageDead(_7);
-          StorageDead(_6);
-          _4 = const Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }};
-          StorageDead(_5);
-          _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }};
-          StorageDead(_4);
-          _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global);
-          StorageDead(_3);
-          _1 = const A {{ foo: Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC2, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global) }};
-          StorageDead(_2);
-          _0 = const ();
-          drop(_1) -> [return: bb1, unwind: bb2];
+          _6 = contract_check_ensures::<{closure@std::ptr::Alignment::of<[bool; 0]>::{closure#0}}, std::ptr::Alignment>(const ZeroSized: {closure@std::ptr::Alignment::of<[bool; 0]>::{closure#0}}, const std::ptr::Alignment::of::<[bool; 0]>::{constant#0}) -> [return: bb3, unwind continue];
       }
 
       bb1: {
@@ -71,11 +67,35 @@
       bb2 (cleanup): {
           resume;
       }
-  }
 
-  ALLOC2 (size: 8, align: 4) { .. }
-
-  ALLOC1 (size: 8, align: 4) { .. }
+      bb3: {
+          StorageLive(_7);
+          StorageLive(_8);
+          _8 = {closure@$SRC_DIR/core/src/ptr/alignment.rs:LL:COL} { 0: copy _6 };
+          StorageLive(_9);
+          _9 = copy _6 as std::num::NonZero<usize> (Transmute);
+          _7 = contract_check_ensures::<{closure@std::ptr::Alignment::as_nonzero::{closure#0}}, NonZero<usize>>(move _8, move _9) -> [return: bb4, unwind continue];
+      }
 
-  ALLOC0 (size: 8, align: 4) { .. }
+      bb4: {
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_10);
+          _10 = copy _7 as *const [bool; 0] (Transmute);
+          _5 = NonNull::<[bool; 0]> { pointer: copy _10 };
+          StorageDead(_10);
+          StorageDead(_7);
+          StorageDead(_6);
+          _4 = Unique::<[bool; 0]> { pointer: move _5, _marker: const PhantomData::<[bool; 0]> };
+          StorageDead(_5);
+          _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize, Implicit));
+          StorageDead(_4);
+          _2 = Box::<[bool]>(copy _3, const std::alloc::Global);
+          StorageDead(_3);
+          _1 = A { foo: move _2 };
+          StorageDead(_2);
+          _0 = const ();
+          drop(_1) -> [return: bb1, unwind: bb2];
+      }
+  }