nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-21 22:34:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #129401 - workingjubilee:partial-initialization-of-stabilization, r=dtolnay,joboet

Browse Source 
Partially stabilize `feature(new_uninit)`

Finished comment period: https://github.com/rust-lang/rust/issues/63291#issuecomment-2183022955

The following API has been stabilized from https://github.com/rust-lang/rust/issues/63291

```rust
impl<T> Box<T> { pub fn new_uninit() -> Box<MaybeUninit<T>> {…} }
impl<T> Rc<T> { pub fn new_uninit() -> Rc<MaybeUninit<T>> {…} }
impl<T> Arc<T> { pub fn new_uninit() -> Arc<MaybeUninit<T>> {…} }

impl<T> Box<[T]> { pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>]> {…} }
impl<T> Rc<[T]> { pub fn new_uninit_slice(len: usize) -> Rc<[MaybeUninit<T>]> {…} }
impl<T> Arc<[T]> { pub fn new_uninit_slice(len: usize) -> Arc<[MaybeUninit<T>]> {…} }

impl<T> Box<MaybeUninit<T>> { pub unsafe fn assume_init(self) -> Box<T> {…} }
impl<T> Box<[MaybeUninit<T>]> { pub unsafe fn assume_init(self) -> Box<[T]> {…} }
impl<T> Rc<MaybeUninit<T>> { pub unsafe fn assume_init(self) -> Rc<T> {…} }
impl<T> Rc<[MaybeUninit<T>]> { pub unsafe fn assume_init(self) -> Rc<[T]> {…} }
impl<T> Arc<MaybeUninit<T>> { pub unsafe fn assume_init(self) -> Arc<T> {…} }
impl<T> Arc<[MaybeUninit<T>]> { pub unsafe fn assume_init(self) -> Arc<[T]> {…} }
```

The remaining API is split between new issues
- `new_zeroed_alloc`: https://github.com/rust-lang/rust/issues/129396
- `box_uninit_write`: https://github.com/rust-lang/rust/issues/129397

All relevant code is thus either stabilized or split out of that issue, so this closes #63291 as, with the FCP concluded, that issue has served its purpose.

try-job: x86_64-rust-for-linux
This commit is contained in:
Jubilee 2024-08-28 19:12:52 -07:00 committed by GitHub
commit 9d5f794312
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
16 changed files with 33 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
compiler/rustc_arena/src/lib.rs
View File

@ -21,7 +21,6 @@
#![feature(decl_macro)]
#![feature(dropck_eyepatch)]
#![feature(maybe_uninit_slice)]
#![feature(new_uninit)]
#![feature(rustc_attrs)]
#![feature(rustdoc_internals)]
#![feature(strict_provenance)]

2
compiler/rustc_index/src/lib.rs
View File

@ -1,7 +1,7 @@
// tidy-alphabetical-start
#![cfg_attr(all(feature = "nightly", test), feature(stmt_expr_attributes))]
#![cfg_attr(feature = "nightly", allow(internal_features))]
#![cfg_attr(feature = "nightly", feature(extend_one, new_uninit, step_trait, test))]
#![cfg_attr(feature = "nightly", feature(extend_one, step_trait, test))]
#![cfg_attr(feature = "nightly", feature(new_zeroed_alloc))]
#![warn(unreachable_pub)]
// tidy-alphabetical-end

1
compiler/rustc_middle/src/lib.rs
View File

@ -53,7 +53,6 @@
#![feature(min_specialization)]
#![feature(negative_impls)]
#![feature(never_type)]
#![feature(new_uninit)]
#![feature(ptr_alignment_type)]
#![feature(rustc_attrs)]
#![feature(rustdoc_internals)]

1
compiler/rustc_span/src/lib.rs
View File

@ -26,7 +26,6 @@
#![feature(let_chains)]
#![feature(min_specialization)]
#![feature(negative_impls)]
#![feature(new_uninit)]
#![feature(read_buf)]
#![feature(round_char_boundary)]
#![feature(rustc_attrs)]

43
library/alloc/src/boxed.rs
View File

@ -262,8 +262,6 @@ impl<T> Box<T> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
///
/// let mut five = Box::<u32>::new_uninit();
///
/// let five = unsafe {
@ -276,7 +274,7 @@ impl<T> Box<T> {
/// assert_eq!(*five, 5)
/// ```
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
#[inline]
pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
@ -292,7 +290,6 @@ impl<T> Box<T> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(new_zeroed_alloc)]
///
/// let zero = Box::<u32>::new_zeroed();
@ -350,7 +347,7 @@ impl<T> Box<T> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// let mut five = Box::<u32>::try_new_uninit()?;
///
@ -380,7 +377,7 @@ impl<T> Box<T> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// let zero = Box::<u32>::try_new_zeroed()?;
/// let zero = unsafe { zero.assume_init() };
@ -460,7 +457,7 @@ impl<T, A: Allocator> Box<T, A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -498,7 +495,7 @@ impl<T, A: Allocator> Box<T, A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -538,7 +535,7 @@ impl<T, A: Allocator> Box<T, A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -576,7 +573,7 @@ impl<T, A: Allocator> Box<T, A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -654,8 +651,6 @@ impl<T> Box<[T]> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
///
/// let mut values = Box::<[u32]>::new_uninit_slice(3);
///
/// let values = unsafe {
@ -670,7 +665,7 @@ impl<T> Box<[T]> {
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
unsafe { RawVec::with_capacity(len).into_box(len) }
@ -686,7 +681,6 @@ impl<T> Box<[T]> {
///
/// ```
/// #![feature(new_zeroed_alloc)]
/// #![feature(new_uninit)]
///
/// let values = Box::<[u32]>::new_zeroed_slice(3);
/// let values = unsafe { values.assume_init() };
@ -708,7 +702,7 @@ impl<T> Box<[T]> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;
/// let values = unsafe {
@ -746,7 +740,7 @@ impl<T> Box<[T]> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// let values = Box::<[u32]>::try_new_zeroed_slice(3)?;
/// let values = unsafe { values.assume_init() };
@ -778,7 +772,7 @@ impl<T, A: Allocator> Box<[T], A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -812,7 +806,7 @@ impl<T, A: Allocator> Box<[T], A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -837,7 +831,7 @@ impl<T, A: Allocator> Box<[T], A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -880,7 +874,7 @@ impl<T, A: Allocator> Box<[T], A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::alloc::System;
///
@ -927,8 +921,6 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
///
/// let mut five = Box::<u32>::new_uninit();
///
/// let five: Box<u32> = unsafe {
@ -940,7 +932,7 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
///
/// assert_eq!(*five, 5)
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[inline]
pub unsafe fn assume_init(self) -> Box<T, A> {
let (raw, alloc) = Box::into_raw_with_allocator(self);
@ -958,7 +950,6 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
///
/// ```
/// #![feature(box_uninit_write)]
/// #![feature(new_uninit)]
///
/// let big_box = Box::<[usize; 1024]>::new_uninit();
///
@ -1001,8 +992,6 @@ impl<T, A: Allocator> Box<[mem::MaybeUninit<T>], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
///
/// let mut values = Box::<[u32]>::new_uninit_slice(3);
///
/// let values = unsafe {
@ -1016,7 +1005,7 @@ impl<T, A: Allocator> Box<[mem::MaybeUninit<T>], A> {
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[inline]
pub unsafe fn assume_init(self) -> Box<[T], A> {
let (raw, alloc) = Box::into_raw_with_allocator(self);

1
library/alloc/src/lib.rs
View File

@ -93,7 +93,6 @@
// tidy-alphabetical-start
#![cfg_attr(not(no_global_oom_handling), feature(const_alloc_error))]
#![cfg_attr(not(no_global_oom_handling), feature(const_btree_len))]
#![cfg_attr(test, feature(new_uninit))]
#![feature(alloc_layout_extra)]
#![feature(allocator_api)]
#![feature(array_chunks)]

26
library/alloc/src/rc.rs
View File

@ -503,7 +503,6 @@ impl<T> Rc<T> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -518,7 +517,7 @@ impl<T> Rc<T> {
/// assert_eq!(*five, 5)
/// ```
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit() -> Rc<mem::MaybeUninit<T>> {
unsafe {
@ -540,7 +539,6 @@ impl<T> Rc<T> {
///
/// ```
/// #![feature(new_zeroed_alloc)]
/// #![feature(new_uninit)]
///
/// use std::rc::Rc;
///
@ -594,7 +592,7 @@ impl<T> Rc<T> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -630,7 +628,7 @@ impl<T> Rc<T> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::rc::Rc;
///
@ -692,7 +690,6 @@ impl<T, A: Allocator> Rc<T, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
/// #![feature(allocator_api)]
///
@ -736,7 +733,6 @@ impl<T, A: Allocator> Rc<T, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::rc::Rc;
@ -799,7 +795,7 @@ impl<T, A: Allocator> Rc<T, A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -843,7 +839,7 @@ impl<T, A: Allocator> Rc<T, A> {
/// # Examples
///
/// ```
/// #![feature(allocator_api, new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::rc::Rc;
/// use std::alloc::System;
@ -967,7 +963,6 @@ impl<T> Rc<[T]> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -985,7 +980,7 @@ impl<T> Rc<[T]> {
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
unsafe { Rc::from_ptr(Rc::allocate_for_slice(len)) }
@ -1000,7 +995,6 @@ impl<T> Rc<[T]> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(new_zeroed_alloc)]
///
/// use std::rc::Rc;
@ -1035,7 +1029,6 @@ impl<T, A: Allocator> Rc<[T], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
/// #![feature(allocator_api)]
///
@ -1072,7 +1065,6 @@ impl<T, A: Allocator> Rc<[T], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::rc::Rc;
@ -1122,7 +1114,6 @@ impl<T, A: Allocator> Rc<mem::MaybeUninit<T>, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -1136,7 +1127,7 @@ impl<T, A: Allocator> Rc<mem::MaybeUninit<T>, A> {
///
/// assert_eq!(*five, 5)
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[inline]
pub unsafe fn assume_init(self) -> Rc<T, A> {
let (ptr, alloc) = Rc::into_inner_with_allocator(self);
@ -1160,7 +1151,6 @@ impl<T, A: Allocator> Rc<[mem::MaybeUninit<T>], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::rc::Rc;
@ -1177,7 +1167,7 @@ impl<T, A: Allocator> Rc<[mem::MaybeUninit<T>], A> {
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[inline]
pub unsafe fn assume_init(self) -> Rc<[T], A> {
let (ptr, alloc) = Rc::into_inner_with_allocator(self);

26
library/alloc/src/sync.rs
View File

@ -505,7 +505,6 @@ impl<T> Arc<T> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -521,7 +520,7 @@ impl<T> Arc<T> {
/// ```
#[cfg(not(no_global_oom_handling))]
#[inline]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit() -> Arc<mem::MaybeUninit<T>> {
unsafe {
@ -543,7 +542,6 @@ impl<T> Arc<T> {
///
/// ```
/// #![feature(new_zeroed_alloc)]
/// #![feature(new_uninit)]
///
/// use std::sync::Arc;
///
@ -614,7 +612,7 @@ impl<T> Arc<T> {
/// # Examples
///
/// ```
/// #![feature(new_uninit, allocator_api)]
/// #![feature(allocator_api)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -650,7 +648,7 @@ impl<T> Arc<T> {
/// # Examples
///
/// ```
/// #![feature(new_uninit, allocator_api)]
/// #![feature( allocator_api)]
///
/// use std::sync::Arc;
///
@ -711,7 +709,6 @@ impl<T, A: Allocator> Arc<T, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
/// #![feature(allocator_api)]
///
@ -755,7 +752,6 @@ impl<T, A: Allocator> Arc<T, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::sync::Arc;
@ -845,7 +841,7 @@ impl<T, A: Allocator> Arc<T, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit, allocator_api)]
/// #![feature(allocator_api)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -889,7 +885,7 @@ impl<T, A: Allocator> Arc<T, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit, allocator_api)]
/// #![feature(allocator_api)]
///
/// use std::sync::Arc;
/// use std::alloc::System;
@ -1101,7 +1097,6 @@ impl<T> Arc<[T]> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -1120,7 +1115,7 @@ impl<T> Arc<[T]> {
/// ```
#[cfg(not(no_global_oom_handling))]
#[inline]
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
unsafe { Arc::from_ptr(Arc::allocate_for_slice(len)) }
@ -1136,7 +1131,6 @@ impl<T> Arc<[T]> {
///
/// ```
/// #![feature(new_zeroed_alloc)]
/// #![feature(new_uninit)]
///
/// use std::sync::Arc;
///
@ -1172,7 +1166,6 @@ impl<T, A: Allocator> Arc<[T], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
/// #![feature(allocator_api)]
///
@ -1208,7 +1201,6 @@ impl<T, A: Allocator> Arc<[T], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(allocator_api)]
///
/// use std::sync::Arc;
@ -1257,7 +1249,6 @@ impl<T, A: Allocator> Arc<mem::MaybeUninit<T>, A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -1271,7 +1262,7 @@ impl<T, A: Allocator> Arc<mem::MaybeUninit<T>, A> {
///
/// assert_eq!(*five, 5)
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "`self` will be dropped if the result is not used"]
#[inline]
pub unsafe fn assume_init(self) -> Arc<T, A> {
@ -1296,7 +1287,6 @@ impl<T, A: Allocator> Arc<[mem::MaybeUninit<T>], A> {
/// # Examples
///
/// ```
/// #![feature(new_uninit)]
/// #![feature(get_mut_unchecked)]
///
/// use std::sync::Arc;
@ -1313,7 +1303,7 @@ impl<T, A: Allocator> Arc<[mem::MaybeUninit<T>], A> {
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
#[unstable(feature = "new_uninit", issue = "63291")]
#[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "`self` will be dropped if the result is not used"]
#[inline]
pub unsafe fn assume_init(self) -> Arc<[T], A> {

1
library/alloc/tests/lib.rs
View File

@ -15,7 +15,6 @@
#![feature(exact_size_is_empty)]
#![feature(linked_list_cursors)]
#![feature(map_try_insert)]
#![feature(new_uninit)]
#![feature(pattern)]
#![feature(trusted_len)]
#![feature(try_reserve_kind)]

1
library/proc_macro/src/lib.rs
View File

@ -28,7 +28,6 @@
#![feature(decl_macro)]
#![feature(maybe_uninit_write_slice)]
#![feature(negative_impls)]
#![feature(new_uninit)]
#![feature(panic_can_unwind)]
#![feature(restricted_std)]
#![feature(rustc_attrs)]

1
library/std/src/lib.rs
View File

@ -362,7 +362,6 @@
#![feature(allocator_api)]
#![feature(get_mut_unchecked)]
#![feature(map_try_insert)]
#![feature(new_uninit)]
#![feature(new_zeroed_alloc)]
#![feature(slice_concat_trait)]
#![feature(thin_box)]

1
src/tools/miri/tests/fail/data_race/alloc_read_race.rs
View File

@ -1,7 +1,6 @@
//@compile-flags: -Zmiri-disable-weak-memory-emulation -Zmiri-preemption-rate=0 -Zmiri-disable-stacked-borrows
// Avoid accidental synchronization via address reuse inside `thread::spawn`.
//@compile-flags: -Zmiri-address-reuse-cross-thread-rate=0
#![feature(new_uninit)]
use std::mem::MaybeUninit;
use std::ptr::null_mut;

1
src/tools/miri/tests/fail/data_race/alloc_write_race.rs
View File

@ -1,7 +1,6 @@
//@compile-flags: -Zmiri-disable-weak-memory-emulation -Zmiri-preemption-rate=0 -Zmiri-disable-stacked-borrows
// Avoid accidental synchronization via address reuse inside `thread::spawn`.
//@compile-flags: -Zmiri-address-reuse-cross-thread-rate=0
#![feature(new_uninit)]
use std::ptr::null_mut;
use std::sync::atomic::{AtomicPtr, Ordering};

1
src/tools/miri/tests/fail/weak_memory/weak_uninit.rs
View File

@ -6,7 +6,6 @@
// run multiple times until one try returns true.
// Spurious failure is possible, if you are really unlucky with
// the RNG and always read the latest value from the store buffer.
#![feature(new_uninit)]
use std::sync::atomic::*;
use std::thread::spawn;

1
src/tools/miri/tests/pass/rc.rs
View File

@ -1,7 +1,6 @@
//@revisions: stack tree
//@[tree]compile-flags: -Zmiri-tree-borrows
//@compile-flags: -Zmiri-strict-provenance
#![feature(new_uninit)]
#![feature(get_mut_unchecked)]
#![allow(ambiguous_wide_pointer_comparisons)]

1
src/tools/miri/tests/pass/slices.rs
View File

@ -1,7 +1,6 @@
//@revisions: stack tree
//@[tree]compile-flags: -Zmiri-tree-borrows
//@compile-flags: -Zmiri-strict-provenance
#![feature(new_uninit)]
#![feature(slice_as_chunks)]
#![feature(slice_partition_dedup)]
#![feature(layout_for_ptr)]