Add various min_const_generics regression tests

src/test/ui/const-generics/min_const_generics/const-argument-if-length.rs

@@ -0,0 +1,18 @@
+#![feature(min_const_generics)]
+
+pub const fn is_zst<T: ?Sized>() -> usize {
+    if std::mem::size_of::<T>() == 0 {
+        1
+    } else {
+        0
+    }
+}
+
+pub struct AtLeastByte<T: ?Sized> {
+    value: T,
+    //~^ ERROR the size for values of type `T` cannot be known at compilation time
+    pad: [u8; is_zst::<T>()],
+    //~^ ERROR generic parameters must not be used inside of non trivial constant values
+}
+
+fn main() {}

src/test/ui/const-generics/min_const_generics/const-argument-if-length.stderr

@@ -0,0 +1,30 @@
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/const-argument-if-length.rs:14:24
+   |
+LL |     pad: [u8; is_zst::<T>()],
+   |                        ^ non-trivial anonymous constants must not depend on the parameter `T`
+   |
+   = note: type parameters are currently not permitted in anonymous constants
+
+error[E0277]: the size for values of type `T` cannot be known at compilation time
+  --> $DIR/const-argument-if-length.rs:12:12
+   |
+LL | pub struct AtLeastByte<T: ?Sized> {
+   |                        - this type parameter needs to be `Sized`
+LL |     value: T,
+   |            ^ doesn't have a size known at compile-time
+   |
+   = note: only the last field of a struct may have a dynamically sized type
+   = help: change the field's type to have a statically known size
+help: borrowed types always have a statically known size
+   |
+LL |     value: &T,
+   |            ^
+help: the `Box` type always has a statically known size and allocates its contents in the heap
+   |
+LL |     value: Box<T>,
+   |            ^^^^ ^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

src/test/ui/const-generics/min_const_generics/generic-function-call-in-array-length.rs

@@ -0,0 +1,11 @@
+#![feature(min_const_generics)]
+
+const fn foo(n: usize) -> usize { n * 2 }
+
+fn bar<const N: usize>() -> [u32; foo(N)] {
+    //~^ ERROR generic parameters must not be used inside of non trivial constant values
+    [0; foo(N)]
+    //~^ ERROR generic parameters must not be used inside of non trivial constant values
+}
+
+fn main() {}

src/test/ui/const-generics/min_const_generics/generic-sum-in-array-length.rs

@@ -0,0 +1,7 @@
+#![feature(min_const_generics)]
+
+fn foo<const A: usize, const B: usize>(bar: [usize; A + B]) {}
+//~^ ERROR generic parameters must not be used inside of non trivial constant values
+//~| ERROR generic parameters must not be used inside of non trivial constant values
+
+fn main() {}

src/test/ui/const-generics/min_const_generics/generic-sum-in-array-length.stderr

@@ -0,0 +1,18 @@
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/generic-sum-in-array-length.rs:3:53
+   |
+LL | fn foo<const A: usize, const B: usize>(bar: [usize; A + B]) {}
+   |                                                     ^ non-trivial anonymous constants must not depend on the parameter `A`
+   |
+   = help: it is currently only allowed to use either `A` or `{ A }` as generic constants
+
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/generic-sum-in-array-length.rs:3:57
+   |
+LL | fn foo<const A: usize, const B: usize>(bar: [usize; A + B]) {}
+   |                                                         ^ non-trivial anonymous constants must not depend on the parameter `B`
+   |
+   = help: it is currently only allowed to use either `B` or `{ B }` as generic constants
+
+error: aborting due to 2 previous errors
+

src/test/ui/const-generics/min_const_generics/intrinsics-type_name-as-const-argument.rs

@@ -0,0 +1,15 @@
+#![feature(min_const_generics)]
+#![feature(core_intrinsics)]
+
+trait Trait<const S: &'static str> {}
+//~^ ERROR `&'static str` is forbidden as the type of a const generic parameter
+
+struct Bug<T>
+where
+    T: Trait<{std::intrinsics::type_name::<T>()}>
+    //~^ ERROR generic parameters must not be used inside of non trivial constant values
+{
+    t: T
+}
+
+fn main() {}

src/test/ui/const-generics/min_const_generics/intrinsics-type_name-as-const-argument.stderr

@@ -0,0 +1,19 @@
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/intrinsics-type_name-as-const-argument.rs:9:44
+   |
+LL |     T: Trait<{std::intrinsics::type_name::<T>()}>
+   |                                            ^ non-trivial anonymous constants must not depend on the parameter `T`
+   |
+   = note: type parameters are currently not permitted in anonymous constants
+
+error: `&'static str` is forbidden as the type of a const generic parameter
+  --> $DIR/intrinsics-type_name-as-const-argument.rs:4:22
+   |
+LL | trait Trait<const S: &'static str> {}
+   |                      ^^^^^^^^^^^^
+   |
+   = note: the only supported types are integers, `bool` and `char`
+   = note: more complex types are supported with `#[feature(const_generics)]`
+
+error: aborting due to 2 previous errors
+

src/test/ui/const-generics/min_const_generics/issue-67375.rs

@@ -0,0 +1,9 @@
+#![feature(min_const_generics)]
+
+struct Bug<T> {
+    //~^ ERROR parameter `T` is never used
+    inner: [(); { [|_: &T| {}; 0].len() }],
+    //~^ ERROR generic parameters must not be used inside of non trivial constant values
+}
+
+fn main() {}

src/test/ui/const-generics/min_const_generics/issue-67375.stderr

@@ -0,0 +1,19 @@
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/issue-67375.rs:5:25
+   |
+LL |     inner: [(); { [|_: &T| {}; 0].len() }],
+   |                         ^ non-trivial anonymous constants must not depend on the parameter `T`
+   |
+   = note: type parameters are currently not permitted in anonymous constants
+
+error[E0392]: parameter `T` is never used
+  --> $DIR/issue-67375.rs:3:12
+   |
+LL | struct Bug<T> {
+   |            ^ unused parameter
+   |
+   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0392`.

src/test/ui/const-generics/min_const_generics/issue-67945-1.rs

@@ -0,0 +1,18 @@
+#![feature(min_const_generics)]
+
+use std::marker::PhantomData;
+
+use std::mem::{self, MaybeUninit};
+
+struct Bug<S> {
+    //~^ ERROR parameter `S` is never used
+    A: [(); {
+        let x: S = MaybeUninit::uninit();
+        //~^ ERROR generic parameters must not be used inside of non trivial constant values
+        let b = &*(&x as *const _ as *const S);
+        //~^ ERROR generic parameters must not be used inside of non trivial constant values
+        0
+    }],
+}
+
+fn main() {}

src/test/ui/const-generics/min_const_generics/issue-67945-1.stderr

@@ -0,0 +1,27 @@
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/issue-67945-1.rs:10:16
+   |
+LL |         let x: S = MaybeUninit::uninit();
+   |                ^ non-trivial anonymous constants must not depend on the parameter `S`
+   |
+   = note: type parameters are currently not permitted in anonymous constants
+
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/issue-67945-1.rs:12:45
+   |
+LL |         let b = &*(&x as *const _ as *const S);
+   |                                             ^ non-trivial anonymous constants must not depend on the parameter `S`
+   |
+   = note: type parameters are currently not permitted in anonymous constants
+
+error[E0392]: parameter `S` is never used
+  --> $DIR/issue-67945-1.rs:7:12
+   |
+LL | struct Bug<S> {
+   |            ^ unused parameter
+   |
+   = help: consider removing `S`, referring to it in a field, or using a marker such as `PhantomData`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0392`.

src/test/ui/const-generics/min_const_generics/issue-67945-2.rs

@@ -0,0 +1,16 @@
+#![feature(min_const_generics)]
+
+use std::mem::MaybeUninit;
+
+struct Bug<S> {
+    //~^ ERROR parameter `S` is never used
+    A: [(); {
+        let x: S = MaybeUninit::uninit();
+        //~^ ERROR generic parameters must not be used inside of non trivial constant values
+        let b = &*(&x as *const _ as *const S);
+        //~^ ERROR generic parameters must not be used inside of non trivial constant values
+        0
+    }],
+}
+
+fn main() {}

src/test/ui/const-generics/min_const_generics/issue-67945-2.stderr

@@ -0,0 +1,27 @@
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/issue-67945-2.rs:8:16
+   |
+LL |         let x: S = MaybeUninit::uninit();
+   |                ^ non-trivial anonymous constants must not depend on the parameter `S`
+   |
+   = note: type parameters are currently not permitted in anonymous constants
+
+error: generic parameters must not be used inside of non trivial constant values
+  --> $DIR/issue-67945-2.rs:10:45
+   |
+LL |         let b = &*(&x as *const _ as *const S);
+   |                                             ^ non-trivial anonymous constants must not depend on the parameter `S`
+   |
+   = note: type parameters are currently not permitted in anonymous constants
+
+error[E0392]: parameter `S` is never used
+  --> $DIR/issue-67945-2.rs:5:12
+   |
+LL | struct Bug<S> {
+   |            ^ unused parameter
+   |
+   = help: consider removing `S`, referring to it in a field, or using a marker such as `PhantomData`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0392`.

src/test/ui/const-generics/min_const_generics/issue-67945-3.rs

@@ -0,0 +1,12 @@
+#![feature(min_const_generics)]
+
+struct Bug<S: ?Sized> {
+    A: [(); {
+        let x: Option<Box<Self>> = None;
+        //~^ ERROR generic `Self` types are currently not permitted in anonymous constants
+        0
+    }],
+    B: S
+}
+
+fn main() {}

src/test/ui/const-generics/min_const_generics/issue-67945-3.stderr

@@ -0,0 +1,8 @@
+error: generic `Self` types are currently not permitted in anonymous constants
+  --> $DIR/issue-67945-3.rs:5:27
+   |
+LL |         let x: Option<Box<Self>> = None;
+   |                           ^^^^
+
+error: aborting due to previous error
+

src/test/ui/const-generics/min_const_generics/static-reference-array-const-param.rs

@@ -0,0 +1,8 @@
+#![feature(min_const_generics)]
+
+fn a<const X: &'static [u32]>() {}
+//~^ ERROR `&'static [u32]` is forbidden as the type of a const generic parameter
+
+fn main() {
+    a::<{&[]}>();
+}

src/test/ui/const-generics/min_const_generics/static-reference-array-const-param.stderr

@@ -0,0 +1,11 @@
+error: `&'static [u32]` is forbidden as the type of a const generic parameter
+  --> $DIR/static-reference-array-const-param.rs:3:15
+   |
+LL | fn a<const X: &'static [u32]>() {}
+   |               ^^^^^^^^^^^^^^
+   |
+   = note: the only supported types are integers, `bool` and `char`
+   = note: more complex types are supported with `#[feature(const_generics)]`
+
+error: aborting due to previous error
+

src/test/ui/const-generics/min_const_generics/transmute-const-param-static-reference.rs

@@ -0,0 +1,12 @@
+#![feature(min_const_generics)]
+
+struct Const<const P: &'static ()>;
+//~^ ERROR `&'static ()` is forbidden as the type of a const generic parameter
+
+fn main() {
+    const A: &'static () = unsafe {
+        std::mem::transmute(10 as *const ())
+    };
+
+    let _ = Const::<{A}>;
+}

src/test/ui/const-generics/min_const_generics/transmute-const-param-static-reference.stderr

@@ -0,0 +1,11 @@
+error: `&'static ()` is forbidden as the type of a const generic parameter
+  --> $DIR/transmute-const-param-static-reference.rs:3:23
+   |
+LL | struct Const<const P: &'static ()>;
+   |                       ^^^^^^^^^^^
+   |
+   = note: the only supported types are integers, `bool` and `char`
+   = note: more complex types are supported with `#[feature(const_generics)]`
+
+error: aborting due to previous error
+