Rollup merge of #127446 - zachs18:miri-stdlib-leaks-core-alloc, r=Mar… · model-checking/verify-rust-std@e9eb7de (original) (raw)

`@@ -274,6 +274,8 @@ impl MaybeUninit {

`

274

274

`/// use std::mem::MaybeUninit;

`

275

275

`///

`

276

276

`/// let v: MaybeUninit<Vec> = MaybeUninit::new(vec![42]);

`

``

277

`+

/// # // Prevent leaks for Miri

`

``

278

`+

/// # unsafe { let _ = MaybeUninit::assume_init(v); }

`

277

279

```` /// ```


`278`

`280`

`///

`

`279`

`281`

`` /// [`assume_init`]: MaybeUninit::assume_init

``

`@@ -446,6 +448,9 @@ impl<T> MaybeUninit<T> {

`

`446`

`448`

`/// let mut x = MaybeUninit::<String>::uninit();

`

`447`

`449`

`///

`

`448`

`450`

`/// x.write("Hello".to_string());

`

``

`451`

`+

/// # // FIXME(https://github.com/rust-lang/miri/issues/3670):

`

``

`452`

`+

/// # // use -Zmiri-disable-leak-check instead of unleaking in tests meant to leak.

`

``

`453`

`+

/// # unsafe { MaybeUninit::assume_init_drop(&mut x); }

`

`449`

`454`

`/// // This leaks the contained string:

`

`450`

`455`

`/// x.write("hello".to_string());

`

`451`

`456`

`/// // x is initialized now:

`

`@@ -506,6 +511,8 @@ impl<T> MaybeUninit<T> {

`

`506`

`511`

`` /// // Create a reference into the `MaybeUninit<T>`. This is okay because we initialized it.

``

`507`

`512`

`/// let x_vec = unsafe { &*x.as_ptr() };

`

`508`

`513`

`/// assert_eq!(x_vec.len(), 3);

`

``

`514`

`+

/// # // Prevent leaks for Miri

`

``

`515`

`+

/// # unsafe { MaybeUninit::assume_init_drop(&mut x); }

`

`509`

`516`

```` /// ```

510

517

`///

`

511

518

`/// Incorrect usage of this method:

`

`@@ -545,6 +552,8 @@ impl MaybeUninit {

`

545

552

`/// let x_vec = unsafe { &mut *x.as_mut_ptr() };

`

546

553

`/// x_vec.push(3);

`

547

554

`/// assert_eq!(x_vec.len(), 4);

`

``

555

`+

/// # // Prevent leaks for Miri

`

``

556

`+

/// # unsafe { MaybeUninit::assume_init_drop(&mut x); }

`

548

557

```` /// ```


`549`

`558`

`///

`

`550`

`559`

`/// *Incorrect* usage of this method:

`

`@@ -746,6 +755,8 @@ impl<T> MaybeUninit<T> {

`

`746`

`755`

`/// use std::mem::MaybeUninit;

`

`747`

`756`

`///

`

`748`

`757`

`/// let mut x = MaybeUninit::<Vec<u32>>::uninit();

`

``

`758`

`+

/// # let mut x_mu = x;

`

``

`759`

`+

/// # let mut x = &mut x_mu;

`

`749`

`760`

`` /// // Initialize `x`:

``

`750`

`761`

`/// x.write(vec![1, 2, 3]);

`

`751`

`762`

`` /// // Now that our `MaybeUninit<_>` is known to be initialized, it is okay to

``

`@@ -755,6 +766,8 @@ impl<T> MaybeUninit<T> {

`

`755`

`766`

`/// x.assume_init_ref()

`

`756`

`767`

`/// };

`

`757`

`768`

`/// assert_eq!(x, &vec![1, 2, 3]);

`

``

`769`

`+

/// # // Prevent leaks for Miri

`

``

`770`

`+

/// # unsafe { MaybeUninit::assume_init_drop(&mut x_mu); }

`

`758`

`771`

```` /// ```

759

772

`///

`

760

773

`/// ### Incorrect usages of this method:

`

`@@ -1088,6 +1101,8 @@ impl MaybeUninit {

`

1088

1101

`/// let init = MaybeUninit::clone_from_slice(&mut dst, &src);

`

1089

1102

`///

`

1090

1103

`/// assert_eq!(init, src);

`

``

1104

`+

/// # // Prevent leaks for Miri

`

``

1105

`+

/// # unsafe { std::ptr::drop_in_place(init); }

`

1091

1106

```` /// ```


`1092`

`1107`

`///

`

`1093`

`1108`

```` /// ```