Rollup merge of rust-lang#155616 - Lars-Schumann:const-array-try-from-vec, r=oli-obk

constify `TryFrom<Vec>` for array

Related issues rust-lang#79597, rust-lang#143773, rust-lang#133214

this makes `Vec` `const Destruct` along the way.

Author: JonathanBrouwer

library/alloc/src/lib.rs

@@ -105,6 +105,7 @@
 #![feature(const_convert)]
 #![feature(const_default)]
 #![feature(const_destruct)]
+#![feature(const_drop_in_place)]
 #![feature(const_eval_select)]
 #![feature(const_heap)]
 #![feature(const_index)]

library/alloc/src/raw_vec/mod.rs

@@ -417,7 +417,8 @@ impl<T, A: Allocator> RawVec<T, A> {
     }
 }
 
-unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec<T, A> {
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+const unsafe impl<#[may_dangle] T, A: [const] Allocator + [const] Destruct> Drop for RawVec<T, A> {
     /// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
     fn drop(&mut self) {
         // SAFETY: We are in a Drop impl, self.inner will not be used again.
@@ -861,7 +862,10 @@ impl<A: Allocator> RawVecInner<A> {
         }
         Ok(())
     }
+}
 
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+const impl<A: [const] Allocator> RawVecInner<A> {
     /// # Safety
     ///
     /// This function deallocates the owned allocation, but does not update `ptr` or `cap` to

library/alloc/src/vec/mod.rs

@@ -79,9 +79,7 @@ use core::cmp::Ordering;
 use core::hash::{Hash, Hasher};
 #[cfg(not(no_global_oom_handling))]
 use core::iter;
-#[cfg(not(no_global_oom_handling))]
-use core::marker::Destruct;
-use core::marker::{Freeze, PhantomData};
+use core::marker::{Destruct, Freeze, PhantomData};
 use core::mem::{self, Assume, ManuallyDrop, MaybeUninit, SizedTypeProperties, TransmuteFrom};
 use core::ops::{self, Index, IndexMut, Range, RangeBounds};
 use core::ptr::{self, NonNull};
@@ -2218,7 +2216,8 @@ impl<T, A: Allocator> Vec<T, A> {
     /// [`spare_capacity_mut()`]: Vec::spare_capacity_mut
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn set_len(&mut self, new_len: usize) {
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+    pub const unsafe fn set_len(&mut self, new_len: usize) {
         ub_checks::assert_unsafe_precondition!(
             check_library_ub,
             "Vec::set_len requires that new_len <= capacity()",
@@ -4288,7 +4287,10 @@ impl<T: Ord, A: Allocator> Ord for Vec<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+const unsafe impl<#[may_dangle] T: [const] Destruct, A: [const] Allocator + [const] Destruct> Drop
+    for Vec<T, A>
+{
     fn drop(&mut self) {
         unsafe {
             // use drop for [T]
@@ -4507,7 +4509,10 @@ impl From<&str> for Vec<u8> {
 }
 
 #[stable(feature = "array_try_from_vec", since = "1.48.0")]
-impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N] {
+#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
+const impl<T: [const] Destruct, A: [const] Allocator + [const] Destruct, const N: usize>
+    TryFrom<Vec<T, A>> for [T; N]
+{
     type Error = Vec<T, A>;
 
     /// Gets the entire contents of the `Vec<T>` as an array,

tests/ui/consts/bad-array-size-in-type-err.stderr

@@ -57,6 +57,10 @@ LL | pub const fn i(_: Wrap) {}
    |                ^         - value is dropped here
    |                |
    |                the destructor for this type cannot be evaluated in constant functions
+   |
+   = note: see issue #133214 <https://github.com/rust-lang/rust/issues/133214> for more information
+   = help: add `#![feature(const_destruct)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 7 previous errors
 

tests/ui/consts/const-eval/issue-65394.stock.stderr

@@ -6,6 +6,10 @@ LL |     let mut x = Vec::<i32>::new();
 ...
 LL | };
    | - value is dropped here
+   |
+   = note: see issue #133214 <https://github.com/rust-lang/rust/issues/133214> for more information
+   = help: add `#![feature(const_destruct)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 1 previous error
 

tests/ui/consts/const-eval/livedrop.stderr

@@ -6,6 +6,10 @@ LL |     let mut always_returned = None;
 ...
 LL |         always_returned = never_returned;
    |         --------------- value is dropped here
+   |
+   = note: see issue #133214 <https://github.com/rust-lang/rust/issues/133214> for more information
+   = help: add `#![feature(const_destruct)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: aborting due to 1 previous error
 

tests/ui/consts/control-flow/drop-fail.precise.stderr

@@ -1,14 +1,14 @@
-error[E0493]: destructor of `Option<Vec<i32>>` cannot be evaluated at compile-time
-  --> $DIR/drop-fail.rs:9:9
+error[E0493]: destructor of `Option<NotConstDestruct>` cannot be evaluated at compile-time
+  --> $DIR/drop-fail.rs:16:9
    |
-LL |     let x = Some(Vec::new());
+LL |     let x = Some(NotConstDestruct);
    |         ^ the destructor for this type cannot be evaluated in constants
 ...
 LL | };
    | - value is dropped here
 
-error[E0493]: destructor of `Option<Vec<i32>>` cannot be evaluated at compile-time
-  --> $DIR/drop-fail.rs:40:9
+error[E0493]: destructor of `Option<NotConstDestruct>` cannot be evaluated at compile-time
+  --> $DIR/drop-fail.rs:47:9
    |
 LL |     let mut tmp = None;
    |         ^^^^^^^ the destructor for this type cannot be evaluated in constants

tests/ui/consts/control-flow/drop-fail.rs

@@ -3,10 +3,17 @@
 #![feature(const_destruct)]
 #![cfg_attr(precise, feature(const_precise_live_drops))]
 
+
+struct NotConstDestruct;
+
+impl Drop for NotConstDestruct {
+    fn drop(&mut self) {}
+}
+
 // `x` is *not* always moved into the final value and may be dropped inside the initializer.
-const _: Option<Vec<i32>> = {
-    let y: Option<Vec<i32>> = None;
-    let x = Some(Vec::new());
+const _: Option<NotConstDestruct> = {
+    let y: Option<NotConstDestruct> = None;
+    let x = Some(NotConstDestruct);
     //[stock,precise]~^ ERROR destructor of
 
     if true {
@@ -18,25 +25,25 @@ const _: Option<Vec<i32>> = {
 
 // We only clear `NeedsDrop` if a local is moved from in entirely. This is a shortcoming of the
 // existing analysis.
-const _: Vec<i32> = {
-    let vec_tuple = (Vec::new(),);
+const _: NotConstDestruct = {
+    let vec_tuple = (NotConstDestruct,);
     //[stock]~^ ERROR destructor of
 
     vec_tuple.0
 };
 
 // This applies to single-field enum variants as well.
-const _: Vec<i32> = {
-    let x: Result<_, Vec<i32>> = Ok(Vec::new());
+const _: NotConstDestruct = {
+    let x: Result<_, NotConstDestruct> = Ok(NotConstDestruct);
     //[stock]~^ ERROR destructor of
 
     match x {
         Ok(x) | Err(x) => x,
     }
 };
 
-const _: Option<Vec<i32>> = {
-    let mut some = Some(Vec::new());
+const _: Option<NotConstDestruct> = {
+    let mut some = Some(NotConstDestruct);
     let mut tmp = None;
     //[stock,precise]~^ ERROR destructor of
 

tests/ui/consts/control-flow/drop-fail.stock.stderr

@@ -1,32 +1,32 @@
-error[E0493]: destructor of `Option<Vec<i32>>` cannot be evaluated at compile-time
-  --> $DIR/drop-fail.rs:9:9
+error[E0493]: destructor of `Option<NotConstDestruct>` cannot be evaluated at compile-time
+  --> $DIR/drop-fail.rs:16:9
    |
-LL |     let x = Some(Vec::new());
+LL |     let x = Some(NotConstDestruct);
    |         ^ the destructor for this type cannot be evaluated in constants
 ...
 LL | };
    | - value is dropped here
 
-error[E0493]: destructor of `(Vec<i32>,)` cannot be evaluated at compile-time
-  --> $DIR/drop-fail.rs:22:9
+error[E0493]: destructor of `(NotConstDestruct,)` cannot be evaluated at compile-time
+  --> $DIR/drop-fail.rs:29:9
    |
-LL |     let vec_tuple = (Vec::new(),);
+LL |     let vec_tuple = (NotConstDestruct,);
    |         ^^^^^^^^^ the destructor for this type cannot be evaluated in constants
 ...
 LL | };
    | - value is dropped here
 
-error[E0493]: destructor of `Result<Vec<i32>, Vec<i32>>` cannot be evaluated at compile-time
-  --> $DIR/drop-fail.rs:30:9
+error[E0493]: destructor of `Result<NotConstDestruct, NotConstDestruct>` cannot be evaluated at compile-time
+  --> $DIR/drop-fail.rs:37:9
    |
-LL |     let x: Result<_, Vec<i32>> = Ok(Vec::new());
+LL |     let x: Result<_, NotConstDestruct> = Ok(NotConstDestruct);
    |         ^ the destructor for this type cannot be evaluated in constants
 ...
 LL | };
    | - value is dropped here
 
-error[E0493]: destructor of `Option<Vec<i32>>` cannot be evaluated at compile-time
-  --> $DIR/drop-fail.rs:40:9
+error[E0493]: destructor of `Option<NotConstDestruct>` cannot be evaluated at compile-time
+  --> $DIR/drop-fail.rs:47:9
    |
 LL |     let mut tmp = None;
    |         ^^^^^^^ the destructor for this type cannot be evaluated in constants

tests/ui/consts/miri_unleashed/assoc_const.rs

@@ -4,6 +4,13 @@
 // a test demonstrating why we do need to run static const qualification on associated constants
 // instead of just checking the final constant
 
+
+struct NotConstDestruct;
+
+impl Drop for NotConstDestruct {
+    fn drop(&mut self) {}
+}
+
 trait Foo<T> {
     const X: T;
 }
@@ -15,18 +22,18 @@ trait Bar<T, U: Foo<T>> {
 impl Foo<u32> for () {
     const X: u32 = 42;
 }
-impl Foo<Vec<u32>> for String {
-    const X: Vec<u32> = Vec::new();
+impl Foo<NotConstDestruct> for NotConstDestruct {
+    const X: NotConstDestruct = NotConstDestruct;
 }
 
 impl Bar<u32, ()> for () {}
-impl Bar<Vec<u32>, String> for String {}
+impl Bar<NotConstDestruct, NotConstDestruct> for NotConstDestruct {}
 
 fn main() {
     // this is fine, but would have been forbidden by the static checks on `F`
     let x = <() as Bar<u32, ()>>::F;
     // this test only causes errors due to the line below, so post-monomorphization
-    let y = <String as Bar<Vec<u32>, String>>::F;
+    let y = <NotConstDestruct as Bar<NotConstDestruct, NotConstDestruct>>::F;
 }
 
 //~? WARN skipping const checks