Fix merge conflicts

Author: carolynzech

library/alloc/Cargo.toml

@@ -10,12 +10,8 @@ edition = "2021"
 
 [dependencies]
 core = { path = "../core" }
-<<<<<<< HEAD
-compiler_builtins = { version = "=0.1.138", features = ['rustc-dep-of-std'] }
-safety = { path = "../contracts/safety" }
-=======
 compiler_builtins = { version = "=0.1.145", features = ['rustc-dep-of-std'] }
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
+safety = { path = "../contracts/safety" }
 
 [dev-dependencies]
 rand = { version = "0.8.5", default-features = false, features = ["alloc"] }

library/alloc/src/lib.rs

@@ -92,12 +92,7 @@
 //
 // Library features:
 // tidy-alphabetical-start
-<<<<<<< HEAD
 #![cfg_attr(kani, feature(kani))]
-#![cfg_attr(not(no_global_oom_handling), feature(const_alloc_error))]
-#![cfg_attr(not(no_global_oom_handling), feature(const_btree_len))]
-=======
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
 #![cfg_attr(test, feature(str_as_str))]
 #![feature(alloc_layout_extra)]
 #![feature(allocator_api)]

library/backtrace

@@ -15,25 +15,9 @@ edition = "2021"
 test = false
 bench = false
 
-<<<<<<< HEAD
-[[test]]
-name = "coretests"
-path = "tests/lib.rs"
-
-[[bench]]
-name = "corebenches"
-path = "benches/lib.rs"
-test = true
-
 [dependencies]
 safety = {path = "../contracts/safety" }
 
-[dev-dependencies]
-rand = { version = "0.8.5", default-features = false }
-rand_xorshift = { version = "0.3.0", default-features = false }
-
-=======
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
 [features]
 # Make panics and failed asserts immediately abort without formatting any message
 panic_immediate_abort = []

library/core/Cargo.toml

@@ -4003,22 +4003,16 @@ pub const fn is_val_statically_known<T: Copy>(_arg: T) -> bool {
 #[rustc_nounwind]
 #[inline]
 #[rustc_intrinsic]
-<<<<<<< HEAD
-// Const-unstable because `swap_nonoverlapping` is const-unstable.
-#[rustc_const_unstable(feature = "const_typed_swap", issue = "none")]
+#[rustc_intrinsic_const_stable_indirect]
+#[rustc_allow_const_fn_unstable(const_swap_nonoverlapping)] // this is anyway not called since CTFE implements the intrinsic
 #[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))]
-pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) {
-=======
-#[rustc_intrinsic_const_stable_indirect]
-#[rustc_allow_const_fn_unstable(const_swap_nonoverlapping)] // this is anyway not called since CTFE implements the intrinsic
 pub const unsafe fn typed_swap_nonoverlapping<T>(x: *mut T, y: *mut T) {
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
     // SAFETY: The caller provided single non-overlapping items behind
     // pointers, so swapping them with `count: 1` is fine.
     unsafe { ptr::swap_nonoverlapping(x, y, 1) };
@@ -4949,24 +4943,27 @@ pub(crate) const fn miri_promise_symbolic_alignment(ptr: *const (), align: usize
 #[cfg(kani)]
 #[unstable(feature = "kani", issue = "none")]
 mod verify {
-    use super::*;
-    use crate::kani;
     use core::mem::MaybeUninit;
     use kani::{AllocationStatus, Arbitrary, ArbitraryPointer, PointerGenerator};
 
-    #[kani::proof_for_contract(typed_swap)]
+    use super::*;
+    use crate::kani;
+
+    #[kani::proof_for_contract(typed_swap_nonoverlapping)]
     pub fn check_typed_swap_u8() {
-        run_with_arbitrary_ptrs::<u8>(|x, y| unsafe { typed_swap(x, y) });
+        run_with_arbitrary_ptrs::<u8>(|x, y| unsafe { typed_swap_nonoverlapping(x, y) });
     }
 
-    #[kani::proof_for_contract(typed_swap)]
+    #[kani::proof_for_contract(typed_swap_nonoverlapping)]
     pub fn check_typed_swap_char() {
-        run_with_arbitrary_ptrs::<char>(|x, y| unsafe { typed_swap(x, y) });
+        run_with_arbitrary_ptrs::<char>(|x, y| unsafe { typed_swap_nonoverlapping(x, y) });
     }
 
-    #[kani::proof_for_contract(typed_swap)]
+    #[kani::proof_for_contract(typed_swap_nonoverlapping)]
     pub fn check_typed_swap_non_zero() {
-        run_with_arbitrary_ptrs::<core::num::NonZeroI32>(|x, y| unsafe { typed_swap(x, y) });
+        run_with_arbitrary_ptrs::<core::num::NonZeroI32>(|x, y| unsafe {
+            typed_swap_nonoverlapping(x, y)
+        });
     }
 
     #[kani::proof_for_contract(copy)]

library/core/src/intrinsics/mod.rs

@@ -2136,11 +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)))]
-        #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(unchecked_shifts))]
-=======
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
         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
@@ -2170,11 +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)))]
-        #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(unchecked_shifts))]
-=======
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
         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

library/core/src/num/int_macros.rs

@@ -1604,68 +1604,8 @@ macro_rules! from_str_int_impl {
     )*}
 }
 
-<<<<<<< HEAD
-from_str_radix! { unsigned u8 u16 u32 u64 u128 }
-from_str_radix! { signed i8 i16 i32 i64 i128 }
-
-// Re-use the relevant implementation of from_str_radix for isize and usize to avoid outputting two
-// identical functions.
-macro_rules! from_str_radix_size_impl {
-    ($($signedness:ident $t:ident $size:ty),*) => {$(
-    impl $size {
-        /// Converts a string slice in a given base to an integer.
-        ///
-        /// The string is expected to be an optional
-        #[doc = sign_dependent_expr!{
-            $signedness ?
-            if signed {
-                " `+` or `-` "
-            }
-            if unsigned {
-                " `+` "
-            }
-        }]
-        /// sign followed by only digits. Leading and trailing non-digit characters (including
-        /// whitespace) represent an error. Underscores (which are accepted in rust literals)
-        /// also represent an error.
-        ///
-        /// Digits are a subset of these characters, depending on `radix`:
-        /// * `0-9`
-        /// * `a-z`
-        /// * `A-Z`
-        ///
-        /// # Panics
-        ///
-        /// This function panics if `radix` is not in the range from 2 to 36.
-        ///
-        /// # Examples
-        ///
-        /// Basic usage:
-        /// ```
-        #[doc = concat!("assert_eq!(", stringify!($size), "::from_str_radix(\"A\", 16), Ok(10));")]
-        /// ```
-        /// Trailing space returns error:
-        /// ```
-        #[doc = concat!("assert!(", stringify!($size), "::from_str_radix(\"1 \", 10).is_err());")]
-        /// ```
-        #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_stable(feature = "const_int_from_str", since = "1.82.0")]
-        #[inline]
-        pub const fn from_str_radix(src: &str, radix: u32) -> Result<$size, ParseIntError> {
-            match <$t>::from_str_radix(src, radix) {
-                Ok(x) => Ok(x as $size),
-                Err(e) => Err(e),
-            }
-        }
-    })*}
-}
-
-#[cfg(target_pointer_width = "16")]
-from_str_radix_size_impl! { signed i16 isize, unsigned u16 usize }
-#[cfg(target_pointer_width = "32")]
-from_str_radix_size_impl! { signed i32 isize, unsigned u32 usize }
-#[cfg(target_pointer_width = "64")]
-from_str_radix_size_impl! { signed i64 isize, unsigned u64 usize }
+from_str_int_impl! { signed isize i8 i16 i32 i64 i128 }
+from_str_int_impl! { unsigned usize u8 u16 u32 u64 u128 }
 
 #[cfg(kani)]
 #[unstable(feature = "kani", issue = "none")]
@@ -2376,7 +2316,3 @@ mod verify {
         checked_f128_to_int_unchecked_usize
     );
 }
-=======
-from_str_int_impl! { signed isize i8 i16 i32 i64 i128 }
-from_str_int_impl! { unsigned usize u8 u16 u32 u64 u128 }
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534

library/core/src/num/mod.rs

@@ -2238,11 +2238,7 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
-<<<<<<< HEAD
-        #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(unchecked_shifts))]
         #[ensures(|result| *result == self << (rhs & (Self::BITS - 1)))]
-=======
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
         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
@@ -2275,11 +2271,7 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
-<<<<<<< HEAD
-        #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(unchecked_shifts))]
         #[ensures(|result| *result == self >> (rhs & (Self::BITS - 1)))]
-=======
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
         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

library/core/src/num/uint_macros.rs

@@ -49,12 +49,9 @@ impl Alignment {
     /// but in an `Alignment` instead of a `usize`.
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
-<<<<<<< HEAD
+    #[must_use]
     #[requires(mem::align_of::<T>().is_power_of_two())]
     #[ensures(|result| result.as_usize().is_power_of_two())]
-=======
-    #[must_use]
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
     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() }

library/core/src/ptr/alignment.rs

@@ -395,12 +395,9 @@
 #![allow(clippy::not_unsafe_ptr_arg_deref)]
 
 use crate::cmp::Ordering;
-<<<<<<< HEAD
+use crate::intrinsics::const_eval_select;
 #[cfg(kani)]
 use crate::kani;
-=======
-use crate::intrinsics::const_eval_select;
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
 use crate::marker::FnPtr;
 use crate::mem::{self, MaybeUninit, SizedTypeProperties};
 use crate::{fmt, hash, intrinsics, ub_checks};

library/core/src/ptr/mod.rs

@@ -332,12 +332,8 @@ impl<T: ?Sized> NonNull<T> {
     /// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
     #[must_use]
     #[inline]
-<<<<<<< HEAD
-    #[stable(feature = "strict_provenance", since = "CURRENT_RUSTC_VERSION")]
-    #[ensures(|result| result.get() == self.as_ptr() as *const() as usize)]
-=======
     #[stable(feature = "strict_provenance", since = "1.84.0")]
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
+    #[ensures(|result| result.get() == self.as_ptr() as *const() as usize)]
     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,12 +361,8 @@ impl<T: ?Sized> NonNull<T> {
     /// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
     #[must_use]
     #[inline]
-<<<<<<< HEAD
-    #[stable(feature = "strict_provenance", since = "CURRENT_RUSTC_VERSION")]
-    #[ensures(|result: &Self| !result.as_ptr().is_null() && result.addr() == addr)]
-=======
     #[stable(feature = "strict_provenance", since = "1.84.0")]
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
+    #[ensures(|result: &Self| !result.as_ptr().is_null() && result.addr() == addr)]
     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 _) }
@@ -384,12 +376,8 @@ impl<T: ?Sized> NonNull<T> {
     /// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
     #[must_use]
     #[inline]
-<<<<<<< HEAD
-    #[stable(feature = "strict_provenance", since = "CURRENT_RUSTC_VERSION")]
-    #[ensures(|result: &Self| !result.as_ptr().is_null())]
-=======
     #[stable(feature = "strict_provenance", since = "1.84.0")]
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
+    #[ensures(|result: &Self| !result.as_ptr().is_null())]
     pub fn map_addr(self, f: impl FnOnce(NonZero<usize>) -> NonZero<usize>) -> Self {
         self.with_addr(f(self.addr()))
     }
@@ -745,16 +733,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
-    #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(unchecked_neg))]
     #[requires(
         count.checked_mul(core::mem::size_of::<T>()).is_some() &&
         count * core::mem::size_of::<T>() <= isize::MAX as usize &&
-        kani::mem::same_allocation(self.as_ptr(), self.as_ptr().wrapping_sub(count))
+        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)))]
-=======
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
     pub const unsafe fn sub(self, count: usize) -> Self
     where
         T: Sized,
@@ -1322,14 +1306,10 @@ impl<T: ?Sized> NonNull<T> {
     /// [`ptr::swap`]: crate::ptr::swap()
     #[inline(always)]
     #[stable(feature = "non_null_convenience", since = "1.80.0")]
-<<<<<<< HEAD
-    #[rustc_const_unstable(feature = "const_swap", issue = "83163")]
+    #[rustc_const_stable(feature = "const_swap", since = "1.85.0")]
     #[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()))]
-=======
-    #[rustc_const_stable(feature = "const_swap", since = "1.85.0")]
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
     pub const unsafe fn swap(self, with: NonNull<T>)
     where
         T: Sized,

library/core/src/ptr/non_null.rs

@@ -98,12 +98,8 @@ impl<T: ?Sized> Unique<T> {
 
     /// Creates a new `Unique` if `ptr` is non-null.
     #[inline]
-<<<<<<< HEAD
-    #[rustc_const_unstable(feature = "const_align_offset", issue = "90962")]
     #[ensures(|result| result.is_none() == ptr.is_null())]
     #[ensures(|result| result.is_none() || result.unwrap().as_ptr() == ptr)]
-=======
->>>>>>> 9c1e515a1356d2d232f1823051c3dc7bd948b534
     pub const fn new(ptr: *mut T) -> Option<Self> {
         if let Some(pointer) = NonNull::new(ptr) {
             Some(Unique { pointer, _marker: PhantomData })