Merge from 249cb84 with conflicts

gitbot · gitbot · commit 59a16d2b553d · 2025-03-14T07:35:05.000Z
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
@@ -11,7 +11,10 @@ edition = "2021"
 [dependencies]
 core = { path = "../core" }
 compiler_builtins = { version = "=0.1.145", features = ['rustc-dep-of-std'] }
+<<<<<<< HEAD
 safety = { path = "../contracts/safety" }
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
 
 [dev-dependencies]
 rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
@@ -92,7 +92,10 @@
 //
 // Library features:
 // tidy-alphabetical-start
+<<<<<<< HEAD
 #![cfg_attr(kani, feature(kani))]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
 #![cfg_attr(test, feature(str_as_str))]
 #![feature(alloc_layout_extra)]
 #![feature(allocator_api)]
diff --git a/library/core/Cargo.toml b/library/core/Cargo.toml
@@ -15,9 +15,12 @@ edition = "2021"
 test = false
 bench = false
 
+<<<<<<< HEAD
 [dependencies]
 safety = {path = "../contracts/safety" }
 
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
 [features]
 # Make panics and failed asserts immediately abort without formatting any message
 panic_immediate_abort = []
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
@@ -4005,13 +4005,16 @@ pub const fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
 #[rustc_intrinsic]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_allow_const_fn_unstable(const_swap_nonoverlapping)] // this is anyway not called since CTFE implements the intrinsic
+<<<<<<< HEAD
 #[cfg_attr(kani, kani::modifies(x))]
 #[cfg_attr(kani, kani::modifies(y))]
 #[requires(ub_checks::can_dereference(x) && ub_checks::can_write(x))]
 #[requires(ub_checks::can_dereference(y) && ub_checks::can_write(y))]
 #[requires(x.addr() != y.addr() || core::mem::size_of::<T>() == 0)]
 #[requires(ub_checks::maybe_is_nonoverlapping(x as *const (), y as *const (), size_of::<T>(), 1))]
 #[ensures(|_| ub_checks::can_dereference(x) && ub_checks::can_dereference(y))]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
 pub const unsafe fn typed_swap_nonoverlapping<T>(x: *mut T, y: *mut T) {
     // SAFETY: The caller provided single non-overlapping items behind
     // pointers, so swapping them with `count: 1` is fine.
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
@@ -2136,7 +2136,10 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
+<<<<<<< HEAD
         #[ensures(|result| *result == self << (rhs & (Self::BITS - 1)))]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
         pub const fn wrapping_shl(self, rhs: u32) -> Self {
             // SAFETY: the masking by the bitsize of the type ensures that we do not shift
             // out of bounds
@@ -2166,7 +2169,10 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
+<<<<<<< HEAD
         #[ensures(|result| *result == self >> (rhs & (Self::BITS - 1)))]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
         pub const fn wrapping_shr(self, rhs: u32) -> Self {
             // SAFETY: the masking by the bitsize of the type ensures that we do not shift
             // out of bounds
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
@@ -1606,6 +1606,7 @@ macro_rules! from_str_int_impl {
 
 from_str_int_impl! { signed isize i8 i16 i32 i64 i128 }
 from_str_int_impl! { unsigned usize u8 u16 u32 u64 u128 }
+<<<<<<< HEAD
 
 #[cfg(kani)]
 #[unstable(feature = "kani", issue = "none")]
@@ -2316,3 +2317,5 @@ mod verify {
         checked_f128_to_int_unchecked_usize
     );
 }
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
@@ -2238,7 +2238,10 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
+<<<<<<< HEAD
         #[ensures(|result| *result == self << (rhs & (Self::BITS - 1)))]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
         pub const fn wrapping_shl(self, rhs: u32) -> Self {
             // SAFETY: the masking by the bitsize of the type ensures that we do not shift
             // out of bounds
@@ -2271,7 +2274,10 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
+<<<<<<< HEAD
         #[ensures(|result| *result == self >> (rhs & (Self::BITS - 1)))]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
         pub const fn wrapping_shr(self, rhs: u32) -> Self {
             // SAFETY: the masking by the bitsize of the type ensures that we do not shift
             // out of bounds
diff --git a/library/core/src/ptr/alignment.rs b/library/core/src/ptr/alignment.rs
@@ -50,8 +50,11 @@ impl Alignment {
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
     #[must_use]
+<<<<<<< HEAD
     #[requires(mem::align_of::<T>().is_power_of_two())]
     #[ensures(|result| result.as_usize().is_power_of_two())]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
     pub const fn of<T>() -> Self {
         // This can't actually panic since type alignment is always a power of two.
         const { Alignment::new(mem::align_of::<T>()).unwrap() }
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
@@ -396,8 +396,11 @@
 
 use crate::cmp::Ordering;
 use crate::intrinsics::const_eval_select;
+<<<<<<< HEAD
 #[cfg(kani)]
 use crate::kani;
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
 use crate::marker::FnPtr;
 use crate::mem::{self, MaybeUninit, SizedTypeProperties};
 use crate::{fmt, hash, intrinsics, ub_checks};
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
@@ -333,7 +333,10 @@ impl<T: ?Sized> NonNull<T> {
     #[must_use]
     #[inline]
     #[stable(feature = "strict_provenance", since = "1.84.0")]
+<<<<<<< HEAD
     #[ensures(|result| result.get() == self.as_ptr() as *const() as usize)]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
     pub fn addr(self) -> NonZero<usize> {
         // SAFETY: The pointer is guaranteed by the type to be non-null,
         // meaning that the address will be non-zero.
@@ -362,7 +365,10 @@ impl<T: ?Sized> NonNull<T> {
     #[must_use]
     #[inline]
     #[stable(feature = "strict_provenance", since = "1.84.0")]
+<<<<<<< HEAD
     #[ensures(|result: &Self| !result.as_ptr().is_null() && result.addr() == addr)]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
     pub fn with_addr(self, addr: NonZero<usize>) -> Self {
         // SAFETY: The result of `ptr::from::with_addr` is non-null because `addr` is guaranteed to be non-zero.
         unsafe { NonNull::new_unchecked(self.as_ptr().with_addr(addr.get()) as *mut _) }
@@ -377,7 +383,10 @@ impl<T: ?Sized> NonNull<T> {
     #[must_use]
     #[inline]
     #[stable(feature = "strict_provenance", since = "1.84.0")]
+<<<<<<< HEAD
     #[ensures(|result: &Self| !result.as_ptr().is_null())]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
     pub fn map_addr(self, f: impl FnOnce(NonZero<usize>) -> NonZero<usize>) -> Self {
         self.with_addr(f(self.addr()))
     }
@@ -737,12 +746,15 @@ impl<T: ?Sized> NonNull<T> {
     #[must_use = "returns a new pointer rather than modifying its argument"]
     #[stable(feature = "non_null_convenience", since = "1.80.0")]
     #[rustc_const_stable(feature = "non_null_convenience", since = "1.80.0")]
+<<<<<<< HEAD
     #[requires(
         count.checked_mul(core::mem::size_of::<T>()).is_some() &&
         count * core::mem::size_of::<T>() <= isize::MAX as usize &&
         core::ub_checks::same_allocation(self.as_ptr(), self.as_ptr().wrapping_sub(count))
     )]
     #[ensures(|result: &NonNull<T>| result.as_ptr() == self.as_ptr().offset(-(count as isize)))]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
     pub const unsafe fn sub(self, count: usize) -> Self
     where
         T: Sized,
@@ -1312,9 +1324,12 @@ impl<T: ?Sized> NonNull<T> {
     #[inline(always)]
     #[stable(feature = "non_null_convenience", since = "1.80.0")]
     #[rustc_const_stable(feature = "const_swap", since = "1.85.0")]
+<<<<<<< HEAD
     #[cfg_attr(kani, kani::modifies(self.as_ptr(), with.as_ptr()))]
     #[requires(ub_checks::can_dereference(self.as_ptr()) && ub_checks::can_write(self.as_ptr()))]
     #[requires(ub_checks::can_dereference(with.as_ptr()) && ub_checks::can_write(with.as_ptr()))]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
     pub const unsafe fn swap(self, with: NonNull<T>)
     where
         T: Sized,
diff --git a/library/core/src/ptr/unique.rs b/library/core/src/ptr/unique.rs
@@ -98,8 +98,11 @@ impl<T: ?Sized> Unique<T> {
 
     /// Creates a new `Unique` if `ptr` is non-null.
     #[inline]
+<<<<<<< HEAD
     #[ensures(|result| result.is_none() == ptr.is_null())]
     #[ensures(|result| result.is_none() || result.unwrap().as_ptr() == ptr)]
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
     pub const fn new(ptr: *mut T) -> Option<Self> {
         if let Some(pointer) = NonNull::new(ptr) {
             Some(Unique { pointer, _marker: PhantomData })
diff --git a/library/core/src/slice/ascii.rs b/library/core/src/slice/ascii.rs
@@ -5,8 +5,11 @@ use core::ascii::EscapeDefault;
 use crate::fmt::{self, Write};
 #[cfg(not(all(target_arch = "x86_64", target_feature = "sse2")))]
 use crate::intrinsics::const_eval_select;
+<<<<<<< HEAD
 #[cfg(kani)]
 use crate::kani;
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
 use crate::{ascii, iter, ops};
 
 #[cfg(not(test))]
@@ -507,6 +510,7 @@ const fn is_ascii(bytes: &[u8]) -> bool {
 
     is_ascii
 }
+<<<<<<< HEAD
 
 #[cfg(kani)]
 #[unstable(feature = "kani", issue = "none")]
@@ -532,3 +536,5 @@ pub mod verify {
         }
     }
 }
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
diff --git a/library/core/src/time.rs b/library/core/src/time.rs
@@ -23,8 +23,11 @@ use safety::{Invariant, ensures};
 
 use crate::fmt;
 use crate::iter::Sum;
+<<<<<<< HEAD
 #[cfg(kani)]
 use crate::kani;
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
 use crate::num::niche_types::Nanoseconds;
 use crate::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 use crate::ub_checks::Invariant;
@@ -43,13 +46,16 @@ const HOURS_PER_DAY: u64 = 24;
 #[unstable(feature = "duration_units", issue = "120301")]
 const DAYS_PER_WEEK: u64 = 7;
 
+<<<<<<< HEAD
 #[unstable(feature = "ub_checks", issue = "none")]
 impl Invariant for Nanoseconds {
     fn is_safe(&self) -> bool {
         self.as_inner() < NANOS_PER_SEC
     }
 }
 
+=======
+>>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
 /// A `Duration` type to represent a span of time, typically used for system
 /// timeouts.
 ///
