Resolve merge conflicts

tautschnig · tautschnig · commit 92ccc71e48bd · 2025-03-14T08:40:36.000Z
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
@@ -11,10 +11,7 @@ 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,10 +92,7 @@
 //
 // 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,12 +15,9 @@ 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,16 +4005,13 @@ 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,10 +2136,7 @@ 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
@@ -2169,10 +2166,7 @@ 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,7 +1606,6 @@ 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")]
@@ -2317,5 +2316,3 @@ 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,10 +2238,7 @@ 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
@@ -2274,10 +2271,7 @@ 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,11 +50,8 @@ 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,11 +396,8 @@
 
 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,10 +333,7 @@ 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.
@@ -365,10 +362,7 @@ 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 _) }
@@ -383,10 +377,7 @@ 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()))
     }
@@ -746,15 +737,12 @@ 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,
@@ -1324,12 +1312,9 @@ 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,11 +98,8 @@ 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,11 +5,8 @@ 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))]
@@ -510,7 +507,6 @@ const fn is_ascii(bytes: &[u8]) -> bool {
 
     is_ascii
 }
-<<<<<<< HEAD
 
 #[cfg(kani)]
 #[unstable(feature = "kani", issue = "none")]
@@ -536,5 +532,3 @@ pub mod verify {
         }
     }
 }
-=======
->>>>>>> 16d4ed08dbd3f6db3007def332f925f9ca7e6b78
diff --git a/library/core/src/time.rs b/library/core/src/time.rs
@@ -23,11 +23,8 @@ 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;
@@ -46,16 +43,13 @@ 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.
 ///
