constify vec![1, 2, 3] macro

Author: Lars-Schumann

library/alloc/src/boxed.rs

@@ -246,7 +246,8 @@ pub struct Box<
 #[rustc_no_mir_inline]
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
 #[cfg(not(no_global_oom_handling))]
-fn box_new_uninit(layout: Layout) -> *mut u8 {
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
+const fn box_new_uninit(layout: Layout) -> *mut u8 {
     match Global.allocate(layout) {
         Ok(ptr) => ptr.as_mut_ptr(),
         Err(_) => handle_alloc_error(layout),
@@ -258,10 +259,11 @@ fn box_new_uninit(layout: Layout) -> *mut u8 {
 /// This is unsafe, but has to be marked as safe or else we couldn't use it in `vec!`.
 #[doc(hidden)]
 #[unstable(feature = "liballoc_internals", issue = "none")]
+#[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 #[inline(always)]
 #[cfg(not(no_global_oom_handling))]
 #[rustc_diagnostic_item = "box_assume_init_into_vec_unsafe"]
-pub fn box_assume_init_into_vec_unsafe<T, const N: usize>(
+pub const fn box_assume_init_into_vec_unsafe<T, const N: usize>(
     b: Box<MaybeUninit<[T; N]>>,
 ) -> crate::vec::Vec<T> {
     unsafe { (b.assume_init() as Box<[T]>).into_vec() }
@@ -307,10 +309,11 @@ impl<T> Box<T> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "new_uninit", since = "1.82.0")]
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     #[must_use]
     #[inline(always)]
     #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
-    pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
+    pub const fn new_uninit() -> Box<mem::MaybeUninit<T>> {
         // This is the same as `Self::new_uninit_in(Global)`, but manually inlined (just like
         // `Box::new`).
 
@@ -1197,8 +1200,9 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
     /// assert_eq!(*five, 5)
     /// ```
     #[stable(feature = "new_uninit", since = "1.82.0")]
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     #[inline(always)]
-    pub unsafe fn assume_init(self) -> Box<T, A> {
+    pub const unsafe fn assume_init(self) -> Box<T, A> {
         // This is used in the `vec!` macro, so we optimize for minimal IR generation
         // even in debug builds.
         // SAFETY: `Box<T>` and `Box<MaybeUninit<T>>` have the same layout.
@@ -1668,8 +1672,9 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     /// [memory layout]: self#memory-layout
     #[must_use = "losing the pointer will leak memory"]
     #[unstable(feature = "allocator_api", issue = "32838")]
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     #[inline]
-    pub fn into_raw_with_allocator(b: Self) -> (*mut T, A) {
+    pub const fn into_raw_with_allocator(b: Self) -> (*mut T, A) {
         let mut b = mem::ManuallyDrop::new(b);
         // We carefully get the raw pointer out in a way that Miri's aliasing model understands what
         // is happening: using the primitive "deref" of `Box`. In case `A` is *not* `Global`, we

library/alloc/src/slice.rs

@@ -476,8 +476,9 @@ impl<T> [T] {
     /// ```
     #[rustc_allow_incoherent_impl]
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     #[inline]
-    pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> {
+    pub const fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> {
         unsafe {
             let len = self.len();
             let (b, alloc) = Box::into_raw_with_allocator(self);

tests/ui/consts/min_const_fn/bad_const_fn_body_ice.rs

@@ -1,7 +1,10 @@
-const fn foo(a: i32) -> Vec<i32> {
+fn non_const() -> Vec<i32> {
     vec![1, 2, 3]
-    //~^ ERROR cannot call non-const
-    //~| ERROR cannot call non-const
+}
+
+const fn foo(a: i32) -> Vec<i32> {
+    non_const()
+    //~^ ERROR cannot call non-const function
 }
 
 fn main() {}

tests/ui/consts/min_const_fn/bad_const_fn_body_ice.stderr

@@ -1,21 +1,16 @@
-error[E0015]: cannot call non-const associated function `Box::<[i32; 3]>::new_uninit` in constant functions
-  --> $DIR/bad_const_fn_body_ice.rs:2:5
+error[E0015]: cannot call non-const function `non_const` in constant functions
+  --> $DIR/bad_const_fn_body_ice.rs:6:5
    |
-LL |     vec![1, 2, 3]
-   |     ^^^^^^^^^^^^^
+LL |     non_const()
+   |     ^^^^^^^^^^^
    |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error[E0015]: cannot call non-const function `std::boxed::box_assume_init_into_vec_unsafe::<i32, 3>` in constant functions
-  --> $DIR/bad_const_fn_body_ice.rs:2:5
-   |
-LL |     vec![1, 2, 3]
-   |     ^^^^^^^^^^^^^
+note: function `non_const` is not const
+  --> $DIR/bad_const_fn_body_ice.rs:1:1
    |
-note: function `box_assume_init_into_vec_unsafe` is not const
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+LL | fn non_const() -> Vec<i32> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0015`.

tests/ui/statics/check-values-constraints.rs

@@ -68,6 +68,10 @@ static STATIC9: SafeStruct = SafeStruct {
     }
 };
 
+fn non_const<T>(value: T) -> Vec<T> {
+    vec![value]
+}
+
 struct UnsafeStruct;
 
 impl Drop for UnsafeStruct {
@@ -78,9 +82,8 @@ static STATIC10: UnsafeStruct = UnsafeStruct;
 
 struct MyOwned;
 
-static STATIC11: Vec<MyOwned> = vec![MyOwned];
+static STATIC11: Vec<MyOwned> = non_const(MyOwned);
 //~^ ERROR cannot call non-const function
-//~| ERROR cannot call non-const
 
 static mut STATIC12: UnsafeStruct = UnsafeStruct;
 
@@ -93,29 +96,23 @@ static mut STATIC14: SafeStruct = SafeStruct {
 };
 
 static STATIC15: &'static [Vec<MyOwned>] = &[
-    vec![MyOwned], //~ ERROR cannot call non-const function
-    //~| ERROR cannot call non-const
-    vec![MyOwned], //~ ERROR cannot call non-const function
-                   //~| ERROR cannot call non-const
+    non_const(MyOwned), //~ ERROR cannot call non-const function
+    non_const(MyOwned), //~ ERROR cannot call non-const function
 ];
 
 static STATIC16: (&'static Vec<MyOwned>, &'static Vec<MyOwned>) = (
-    &vec![MyOwned], //~ ERROR cannot call non-const function
-    //~| ERROR cannot call non-const
-    &vec![MyOwned], //~ ERROR cannot call non-const function
-                    //~| ERROR cannot call non-const
+    &non_const(MyOwned), //~ ERROR cannot call non-const function
+    &non_const(MyOwned), //~ ERROR cannot call non-const function
 );
 
 static mut STATIC17: SafeEnum = SafeEnum::Variant1;
 
-static STATIC19: Vec<isize> = vec![3];
+static STATIC19: Vec<isize> = non_const(3);
 //~^ ERROR cannot call non-const function
-//~| ERROR cannot call non-const
 
 pub fn main() {
     let y = {
-        static x: Vec<isize> = vec![3]; //~ ERROR cannot call non-const function
-        //~| ERROR cannot call non-const
+        static x: Vec<isize> = non_const(3); //~ ERROR cannot call non-const function
         x
         //~^ ERROR cannot move out of static
     };

tests/ui/statics/check-values-constraints.stderr

@@ -11,28 +11,22 @@ LL | |     }
 LL |   };
    |   - value is dropped here
 
-error[E0015]: cannot call non-const associated function `Box::<[MyOwned; 1]>::new_uninit` in statics
-  --> $DIR/check-values-constraints.rs:81:33
+error[E0015]: cannot call non-const function `non_const::<MyOwned>` in statics
+  --> $DIR/check-values-constraints.rs:85:33
    |
-LL | static STATIC11: Vec<MyOwned> = vec![MyOwned];
-   |                                 ^^^^^^^^^^^^^
+LL | static STATIC11: Vec<MyOwned> = non_const(MyOwned);
+   |                                 ^^^^^^^^^^^^^^^^^^
    |
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
-
-error[E0015]: cannot call non-const function `std::boxed::box_assume_init_into_vec_unsafe::<MyOwned, 1>` in statics
-  --> $DIR/check-values-constraints.rs:81:33
-   |
-LL | static STATIC11: Vec<MyOwned> = vec![MyOwned];
-   |                                 ^^^^^^^^^^^^^
+note: function `non_const` is not const
+  --> $DIR/check-values-constraints.rs:71:1
    |
-note: function `box_assume_init_into_vec_unsafe` is not const
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+LL | fn non_const<T>(value: T) -> Vec<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
 error[E0015]: cannot call non-const method `<str as ToString>::to_string` in statics
-  --> $DIR/check-values-constraints.rs:92:38
+  --> $DIR/check-values-constraints.rs:95:38
    |
 LL |     field2: SafeEnum::Variant4("str".to_string()),
    |                                      ^^^^^^^^^^^
@@ -47,128 +41,92 @@ note: method `to_string` is not const because trait `ToString` is not const
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
-error[E0015]: cannot call non-const associated function `Box::<[MyOwned; 1]>::new_uninit` in statics
-  --> $DIR/check-values-constraints.rs:96:5
+error[E0015]: cannot call non-const function `non_const::<MyOwned>` in statics
+  --> $DIR/check-values-constraints.rs:99:5
    |
-LL |     vec![MyOwned],
-   |     ^^^^^^^^^^^^^
-   |
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
-
-error[E0015]: cannot call non-const function `std::boxed::box_assume_init_into_vec_unsafe::<MyOwned, 1>` in statics
-  --> $DIR/check-values-constraints.rs:96:5
+LL |     non_const(MyOwned),
+   |     ^^^^^^^^^^^^^^^^^^
    |
-LL |     vec![MyOwned],
-   |     ^^^^^^^^^^^^^
+note: function `non_const` is not const
+  --> $DIR/check-values-constraints.rs:71:1
    |
-note: function `box_assume_init_into_vec_unsafe` is not const
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+LL | fn non_const<T>(value: T) -> Vec<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
-error[E0015]: cannot call non-const associated function `Box::<[MyOwned; 1]>::new_uninit` in statics
-  --> $DIR/check-values-constraints.rs:98:5
+error[E0015]: cannot call non-const function `non_const::<MyOwned>` in statics
+  --> $DIR/check-values-constraints.rs:100:5
    |
-LL |     vec![MyOwned],
-   |     ^^^^^^^^^^^^^
+LL |     non_const(MyOwned),
+   |     ^^^^^^^^^^^^^^^^^^
    |
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
-
-error[E0015]: cannot call non-const function `std::boxed::box_assume_init_into_vec_unsafe::<MyOwned, 1>` in statics
-  --> $DIR/check-values-constraints.rs:98:5
-   |
-LL |     vec![MyOwned],
-   |     ^^^^^^^^^^^^^
+note: function `non_const` is not const
+  --> $DIR/check-values-constraints.rs:71:1
    |
-note: function `box_assume_init_into_vec_unsafe` is not const
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+LL | fn non_const<T>(value: T) -> Vec<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
-error[E0015]: cannot call non-const associated function `Box::<[MyOwned; 1]>::new_uninit` in statics
-  --> $DIR/check-values-constraints.rs:103:6
+error[E0015]: cannot call non-const function `non_const::<MyOwned>` in statics
+  --> $DIR/check-values-constraints.rs:104:6
    |
-LL |     &vec![MyOwned],
-   |      ^^^^^^^^^^^^^
+LL |     &non_const(MyOwned),
+   |      ^^^^^^^^^^^^^^^^^^
    |
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
-
-error[E0015]: cannot call non-const function `std::boxed::box_assume_init_into_vec_unsafe::<MyOwned, 1>` in statics
-  --> $DIR/check-values-constraints.rs:103:6
+note: function `non_const` is not const
+  --> $DIR/check-values-constraints.rs:71:1
    |
-LL |     &vec![MyOwned],
-   |      ^^^^^^^^^^^^^
-   |
-note: function `box_assume_init_into_vec_unsafe` is not const
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+LL | fn non_const<T>(value: T) -> Vec<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
-error[E0015]: cannot call non-const associated function `Box::<[MyOwned; 1]>::new_uninit` in statics
+error[E0015]: cannot call non-const function `non_const::<MyOwned>` in statics
   --> $DIR/check-values-constraints.rs:105:6
    |
-LL |     &vec![MyOwned],
-   |      ^^^^^^^^^^^^^
+LL |     &non_const(MyOwned),
+   |      ^^^^^^^^^^^^^^^^^^
    |
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
-
-error[E0015]: cannot call non-const function `std::boxed::box_assume_init_into_vec_unsafe::<MyOwned, 1>` in statics
-  --> $DIR/check-values-constraints.rs:105:6
-   |
-LL |     &vec![MyOwned],
-   |      ^^^^^^^^^^^^^
+note: function `non_const` is not const
+  --> $DIR/check-values-constraints.rs:71:1
    |
-note: function `box_assume_init_into_vec_unsafe` is not const
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+LL | fn non_const<T>(value: T) -> Vec<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
-error[E0015]: cannot call non-const associated function `Box::<[isize; 1]>::new_uninit` in statics
-  --> $DIR/check-values-constraints.rs:111:31
-   |
-LL | static STATIC19: Vec<isize> = vec![3];
-   |                               ^^^^^^^
+error[E0015]: cannot call non-const function `non_const::<isize>` in statics
+  --> $DIR/check-values-constraints.rs:110:31
    |
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
-
-error[E0015]: cannot call non-const function `std::boxed::box_assume_init_into_vec_unsafe::<isize, 1>` in statics
-  --> $DIR/check-values-constraints.rs:111:31
+LL | static STATIC19: Vec<isize> = non_const(3);
+   |                               ^^^^^^^^^^^^
    |
-LL | static STATIC19: Vec<isize> = vec![3];
-   |                               ^^^^^^^
+note: function `non_const` is not const
+  --> $DIR/check-values-constraints.rs:71:1
    |
-note: function `box_assume_init_into_vec_unsafe` is not const
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+LL | fn non_const<T>(value: T) -> Vec<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
-error[E0015]: cannot call non-const associated function `Box::<[isize; 1]>::new_uninit` in statics
-  --> $DIR/check-values-constraints.rs:117:32
-   |
-LL |         static x: Vec<isize> = vec![3];
-   |                                ^^^^^^^
+error[E0015]: cannot call non-const function `non_const::<isize>` in statics
+  --> $DIR/check-values-constraints.rs:115:32
    |
-   = note: calls in statics are limited to constant functions, tuple structs and tuple variants
-   = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
-
-error[E0015]: cannot call non-const function `std::boxed::box_assume_init_into_vec_unsafe::<isize, 1>` in statics
-  --> $DIR/check-values-constraints.rs:117:32
+LL |         static x: Vec<isize> = non_const(3);
+   |                                ^^^^^^^^^^^^
    |
-LL |         static x: Vec<isize> = vec![3];
-   |                                ^^^^^^^
+note: function `non_const` is not const
+  --> $DIR/check-values-constraints.rs:71:1
    |
-note: function `box_assume_init_into_vec_unsafe` is not const
-  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+LL | fn non_const<T>(value: T) -> Vec<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
 
 error[E0507]: cannot move out of static item `x`
-  --> $DIR/check-values-constraints.rs:119:9
+  --> $DIR/check-values-constraints.rs:116:9
    |
 LL |         x
    |         ^ move occurs because `x` has type `Vec<isize>`, which does not implement the `Copy` trait
@@ -182,7 +140,7 @@ help: consider cloning the value if the performance cost is acceptable
 LL |         x.clone()
    |          ++++++++
 
-error: aborting due to 17 previous errors
+error: aborting due to 10 previous errors
 
 Some errors have detailed explanations: E0015, E0493, E0507.
 For more information about an error, try `rustc --explain E0015`.