add tests

4 files changed, 352 insertions, 36 deletions

diff --git a/tests/ui/const-generics/early/const_arg_trivial_macro_expansion.rs b/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-1.rs
index 2fdd703ab6f..5ea445520f1 100644
--- a/tests/ui/const-generics/early/const_arg_trivial_macro_expansion.rs
+++ b/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-1.rs
@@ -85,6 +85,14 @@ macro_rules! braced_braced_expr {
     () => {{ braced_expr!() }};
 }
 
+macro_rules! closure {
+    () => { |()| () };
+}
+
+macro_rules! empty {
+    () => {};
+}
+
 #[rustfmt::skip]
 mod array_paren_call {
     // Arrays where the expanded result is a `Res::Err`
@@ -128,6 +136,14 @@ mod array_paren_call {
     fn array_33() -> [(); braced_expr!()] { loop {} }
     fn array_34() -> [(); { unbraced_expr!() }] { loop {} }
     fn array_35() -> [(); { braced_expr!() }] { loop {} }
+
+    // Arrays whose expanded form contains a nested definition
+    fn array_36() -> [(); closure!()] { loop {} }
+    fn array_37() -> [(); { closure!() }] { loop {} }
+
+    // Arrays whose macro expansion is empty
+    fn array_38() -> [(); empty!()] { loop {} }
+    fn array_39() -> [(); { empty!() }] { loop {} }
 }
 
 #[rustfmt::skip]
@@ -173,6 +189,14 @@ mod array_brace_call {
     fn array_33() -> [(); braced_expr!{}] { loop {} }
     fn array_34() -> [(); { unbraced_expr!{} }] { loop {} }
     fn array_35() -> [(); { braced_expr!{} }] { loop {} }
+
+    // Arrays whose expanded form contains a nested definition
+    fn array_36() -> [(); closure!{}] { loop {} }
+    fn array_37() -> [(); { closure!{} }] { loop {} }
+
+    // Arrays whose macro expansion is empty
+    fn array_38() -> [(); empty!{}] { loop {} }
+    fn array_39() -> [(); { empty!{} }] { loop {} }
 }
 
 #[rustfmt::skip]
@@ -218,6 +242,14 @@ mod array_square_call {
     fn array_33() -> [(); braced_expr![]] { loop {} }
     fn array_34() -> [(); { unbraced_expr![] }] { loop {} }
     fn array_35() -> [(); { braced_expr![] }] { loop {} }
+
+    // Arrays whose expanded form contains a nested definition
+    fn array_36() -> [(); closure![]] { loop {} }
+    fn array_37() -> [(); { closure![] }] { loop {} }
+
+    // Arrays whose macro expansion is empty
+    fn array_38() -> [(); empty![]] { loop {} }
+    fn array_39() -> [(); { empty![] }] { loop {} }
 }
 
 struct Foo<const N: usize>;
@@ -255,18 +287,26 @@ mod adt_paren_call {
     fn adt_23<const ident: usize>() -> Foo<{ braced_ident!() }> { loop {} }
 
     // An ADT where the expanded result is a complex expr
-    fn array_24() -> Foo<unbraced_unbraced_expr!()> { loop {} }
-    fn array_25() -> Foo<braced_unbraced_expr!()> { loop {} }
-    fn array_26() -> Foo<unbraced_braced_expr!()> { loop {} }
-    fn array_27() -> Foo<braced_braced_expr!()> { loop {} }
-    fn array_28() -> Foo<{ unbraced_unbraced_expr!() }> { loop {} }
-    fn array_29() -> Foo<{ braced_unbraced_expr!() }> { loop {} }
-    fn array_30() -> Foo<{ unbraced_braced_expr!() }> { loop {} }
-    fn array_31() -> Foo<{ braced_braced_expr!() }> { loop {} }
-    fn array_32() -> Foo<unbraced_expr!()> { loop {} }
-    fn array_33() -> Foo<braced_expr!()> { loop {} }
-    fn array_34() -> Foo<{ unbraced_expr!() }> { loop {} }
-    fn array_35() -> Foo<{ braced_expr!() }> { loop {} }
+    fn adt_24() -> Foo<unbraced_unbraced_expr!()> { loop {} }
+    fn adt_25() -> Foo<braced_unbraced_expr!()> { loop {} }
+    fn adt_26() -> Foo<unbraced_braced_expr!()> { loop {} }
+    fn adt_27() -> Foo<braced_braced_expr!()> { loop {} }
+    fn adt_28() -> Foo<{ unbraced_unbraced_expr!() }> { loop {} }
+    fn adt_29() -> Foo<{ braced_unbraced_expr!() }> { loop {} }
+    fn adt_30() -> Foo<{ unbraced_braced_expr!() }> { loop {} }
+    fn adt_31() -> Foo<{ braced_braced_expr!() }> { loop {} }
+    fn adt_32() -> Foo<unbraced_expr!()> { loop {} }
+    fn adt_33() -> Foo<braced_expr!()> { loop {} }
+    fn adt_34() -> Foo<{ unbraced_expr!() }> { loop {} }
+    fn adt_35() -> Foo<{ braced_expr!() }> { loop {} }
+
+    // An ADT whose expanded form contains a nested definition
+    fn adt_36() -> Foo<closure!()> { loop {} }
+    fn adt_37() -> Foo<{ closure!() }> { loop {} }
+
+    // An ADT whose macro expansion is empty
+    fn adt_38() -> Foo<empty!()> { loop {} }
+    fn adt_39() -> Foo<{ empty!() }> { loop {} }
 }
 
 #[rustfmt::skip]
@@ -302,18 +342,26 @@ mod adt_brace_call {
     fn adt_23<const ident: usize>() -> Foo<{ braced_ident!{} }> { loop {} }
 
     // An ADT where the expanded result is a complex expr
-    fn array_24() -> Foo<unbraced_unbraced_expr!{}> { loop {} }
-    fn array_25() -> Foo<braced_unbraced_expr!{}> { loop {} }
-    fn array_26() -> Foo<unbraced_braced_expr!{}> { loop {} }
-    fn array_27() -> Foo<braced_braced_expr!{}> { loop {} }
-    fn array_28() -> Foo<{ unbraced_unbraced_expr!{} }> { loop {} }
-    fn array_29() -> Foo<{ braced_unbraced_expr!{} }> { loop {} }
-    fn array_30() -> Foo<{ unbraced_braced_expr!{} }> { loop {} }
-    fn array_31() -> Foo<{ braced_braced_expr!{} }> { loop {} }
-    fn array_32() -> Foo<unbraced_expr!{}> { loop {} }
-    fn array_33() -> Foo<braced_expr!{}> { loop {} }
-    fn array_34() -> Foo<{ unbraced_expr!{} }> { loop {} }
-    fn array_35() -> Foo<{ braced_expr!{} }> { loop {} }
+    fn adt_24() -> Foo<unbraced_unbraced_expr!{}> { loop {} }
+    fn adt_25() -> Foo<braced_unbraced_expr!{}> { loop {} }
+    fn adt_26() -> Foo<unbraced_braced_expr!{}> { loop {} }
+    fn adt_27() -> Foo<braced_braced_expr!{}> { loop {} }
+    fn adt_28() -> Foo<{ unbraced_unbraced_expr!{} }> { loop {} }
+    fn adt_29() -> Foo<{ braced_unbraced_expr!{} }> { loop {} }
+    fn adt_30() -> Foo<{ unbraced_braced_expr!{} }> { loop {} }
+    fn adt_31() -> Foo<{ braced_braced_expr!{} }> { loop {} }
+    fn adt_32() -> Foo<unbraced_expr!{}> { loop {} }
+    fn adt_33() -> Foo<braced_expr!{}> { loop {} }
+    fn adt_34() -> Foo<{ unbraced_expr!{} }> { loop {} }
+    fn adt_35() -> Foo<{ braced_expr!{} }> { loop {} }
+
+    // An ADT whose expanded form contains a nested definition
+    fn adt_36() -> Foo<closure!{}> { loop {} }
+    fn adt_37() -> Foo<{ closure!{} }> { loop {} }
+
+    // An ADT whose macro expansion is empty
+    fn adt_38() -> Foo<empty!{}> { loop {} }
+    fn adt_39() -> Foo<{ empty!{} }> { loop {} }
 }
 
 #[rustfmt::skip]
@@ -349,18 +397,185 @@ mod adt_square_call {
     fn adt_23<const ident: usize>() -> Foo<{ braced_ident![] }> { loop {} }
 
     // An ADT where the expanded result is a complex expr
-    fn array_24() -> Foo<unbraced_unbraced_expr![]> { loop {} }
-    fn array_25() -> Foo<braced_unbraced_expr![]> { loop {} }
-    fn array_26() -> Foo<unbraced_braced_expr![]> { loop {} }
-    fn array_27() -> Foo<braced_braced_expr![]> { loop {} }
-    fn array_28() -> Foo<{ unbraced_unbraced_expr![] }> { loop {} }
-    fn array_29() -> Foo<{ braced_unbraced_expr![] }> { loop {} }
-    fn array_30() -> Foo<{ unbraced_braced_expr![] }> { loop {} }
-    fn array_31() -> Foo<{ braced_braced_expr![] }> { loop {} }
-    fn array_32() -> Foo<unbraced_expr![]> { loop {} }
-    fn array_33() -> Foo<braced_expr![]> { loop {} }
-    fn array_34() -> Foo<{ unbraced_expr![] }> { loop {} }
-    fn array_35() -> Foo<{ braced_expr![] }> { loop {} }
+    fn adt_24() -> Foo<unbraced_unbraced_expr![]> { loop {} }
+    fn adt_25() -> Foo<braced_unbraced_expr![]> { loop {} }
+    fn adt_26() -> Foo<unbraced_braced_expr![]> { loop {} }
+    fn adt_27() -> Foo<braced_braced_expr![]> { loop {} }
+    fn adt_28() -> Foo<{ unbraced_unbraced_expr![] }> { loop {} }
+    fn adt_29() -> Foo<{ braced_unbraced_expr![] }> { loop {} }
+    fn adt_30() -> Foo<{ unbraced_braced_expr![] }> { loop {} }
+    fn adt_31() -> Foo<{ braced_braced_expr![] }> { loop {} }
+    fn adt_32() -> Foo<unbraced_expr![]> { loop {} }
+    fn adt_33() -> Foo<braced_expr![]> { loop {} }
+    fn adt_34() -> Foo<{ unbraced_expr![] }> { loop {} }
+    fn adt_35() -> Foo<{ braced_expr![] }> { loop {} }
+
+    // An ADT whose expanded form contains a nested definition
+    fn adt_36() -> Foo<closure![]> { loop {} }
+    fn adt_37() -> Foo<{ closure![] }> { loop {} }
+
+    // An ADT whose macro expansion is empty
+    fn adt_38() -> Foo<empty![]> { loop {} }
+    fn adt_39() -> Foo<{ empty![] }> { loop {} }
+}
+
+#[rustfmt::skip]
+mod repeat_paren_call {
+    // A repeat expr where the expanded result is a `Res::Err`
+    fn repeat_0() { [(); unbraced_unbraced_ident!()]; }
+    fn repeat_1() { [(); braced_unbraced_ident!()]; }
+    fn repeat_2() { [(); unbraced_braced_ident!()]; }
+    fn repeat_3() { [(); braced_braced_ident!()]; }
+    fn repeat_4() { [(); { unbraced_unbraced_ident!() }]; }
+    fn repeat_5() { [(); { braced_unbraced_ident!() }]; }
+    fn repeat_6() { [(); { unbraced_braced_ident!() }]; }
+    fn repeat_7() { [(); { braced_braced_ident!() }]; }
+    fn repeat_8() { [(); unbraced_ident!()]; }
+    fn repeat_9() { [(); braced_ident!()]; }
+    fn repeat_10() { [(); { unbraced_ident!() }]; }
+    fn repeat_11() { [(); { braced_ident!() }]; }
+
+    // A repeat expr where the expanded result is a `Res::ConstParam`
+    fn repeat_12<const ident: usize>() { [(); unbraced_unbraced_ident!()]; }
+    fn repeat_13<const ident: usize>() { [(); braced_unbraced_ident!()]; }
+    fn repeat_14<const ident: usize>() { [(); unbraced_braced_ident!()]; }
+    fn repeat_15<const ident: usize>() { [(); braced_braced_ident!()]; }
+    fn repeat_16<const ident: usize>() { [(); { unbraced_unbraced_ident!() }]; }
+    fn repeat_17<const ident: usize>() { [(); { braced_unbraced_ident!() }]; }
+    fn repeat_18<const ident: usize>() { [(); { unbraced_braced_ident!() }]; }
+    fn repeat_19<const ident: usize>() { [(); { braced_braced_ident!() }]; }
+    fn repeat_20<const ident: usize>() { [(); unbraced_ident!()]; }
+    fn repeat_21<const ident: usize>() { [(); braced_ident!()]; }
+    fn repeat_22<const ident: usize>() { [(); { unbraced_ident!() }]; }
+    fn repeat_23<const ident: usize>() { [(); { braced_ident!() }]; }
+
+    // A repeat expr where the expanded result is a complex expr
+    fn repeat_24() { [(); unbraced_unbraced_expr!()]; }
+    fn repeat_25() { [(); braced_unbraced_expr!()]; }
+    fn repeat_26() { [(); unbraced_braced_expr!()]; }
+    fn repeat_27() { [(); braced_braced_expr!()]; }
+    fn repeat_28() { [(); { unbraced_unbraced_expr!() }]; }
+    fn repeat_29() { [(); { braced_unbraced_expr!() }]; }
+    fn repeat_30() { [(); { unbraced_braced_expr!() }]; }
+    fn repeat_31() { [(); { braced_braced_expr!() }]; }
+    fn repeat_32() { [(); unbraced_expr!()]; }
+    fn repeat_33() { [(); braced_expr!()]; }
+    fn repeat_34() { [(); { unbraced_expr!() }]; }
+    fn repeat_35() { [(); { braced_expr!() }]; }
+
+    // A repeat expr whose expanded form contains a nested definition
+    fn repeat_36() { [(); closure!()] }
+    fn repeat_37() { [(); { closure!() }] }
+
+    // A repeat expr whose macro expansion is empty
+    fn repeat_38() { [(); empty!()] }
+    fn repeat_39() { [(); { empty!() }] }
+}
+
+#[rustfmt::skip]
+mod repeat_brace_call {
+    // A repeat expr where the expanded result is a `Res::Err`
+    fn repeat_0() { [(); unbraced_unbraced_ident!{}]; }
+    fn repeat_1() { [(); braced_unbraced_ident!{}]; }
+    fn repeat_2() { [(); unbraced_braced_ident!{}]; }
+    fn repeat_3() { [(); braced_braced_ident!{}]; }
+    fn repeat_4() { [(); { unbraced_unbraced_ident!{} }]; }
+    fn repeat_5() { [(); { braced_unbraced_ident!{} }]; }
+    fn repeat_6() { [(); { unbraced_braced_ident!{} }]; }
+    fn repeat_7() { [(); { braced_braced_ident!{} }]; }
+    fn repeat_8() { [(); unbraced_ident!{}]; }
+    fn repeat_9() { [(); braced_ident!{}]; }
+    fn repeat_10() { [(); { unbraced_ident!{} }]; }
+    fn repeat_11() { [(); { braced_ident!{} }]; }
+
+    // A repeat expr where the expanded result is a `Res::ConstParam`
+    fn repeat_12<const ident: usize>() { [(); unbraced_unbraced_ident!{}]; }
+    fn repeat_13<const ident: usize>() { [(); braced_unbraced_ident!{}]; }
+    fn repeat_14<const ident: usize>() { [(); unbraced_braced_ident!{}]; }
+    fn repeat_15<const ident: usize>() { [(); braced_braced_ident!{}]; }
+    fn repeat_16<const ident: usize>() { [(); { unbraced_unbraced_ident!{} }]; }
+    fn repeat_17<const ident: usize>() { [(); { braced_unbraced_ident!{} }]; }
+    fn repeat_18<const ident: usize>() { [(); { unbraced_braced_ident!{} }]; }
+    fn repeat_19<const ident: usize>() { [(); { braced_braced_ident!{} }]; }
+    fn repeat_20<const ident: usize>() { [(); unbraced_ident!{}]; }
+    fn repeat_21<const ident: usize>() { [(); braced_ident!{}]; }
+    fn repeat_22<const ident: usize>() { [(); { unbraced_ident!{} }]; }
+    fn repeat_23<const ident: usize>() { [(); { braced_ident!{} }]; }
+
+    // A repeat expr where the expanded result is a complex expr
+    fn repeat_24() { [(); unbraced_unbraced_expr!{}]; }
+    fn repeat_25() { [(); braced_unbraced_expr!{}]; }
+    fn repeat_26() { [(); unbraced_braced_expr!{}]; }
+    fn repeat_27() { [(); braced_braced_expr!{}]; }
+    fn repeat_28() { [(); { unbraced_unbraced_expr!{} }]; }
+    fn repeat_29() { [(); { braced_unbraced_expr!{} }]; }
+    fn repeat_30() { [(); { unbraced_braced_expr!{} }]; }
+    fn repeat_31() { [(); { braced_braced_expr!{} }]; }
+    fn repeat_32() { [(); unbraced_expr!{}]; }
+    fn repeat_33() { [(); braced_expr!{}]; }
+    fn repeat_34() { [(); { unbraced_expr!{} }]; }
+    fn repeat_35() { [(); { braced_expr!{} }]; }
+
+    // A repeat expr whose expanded form contains a nested definition
+    fn repeat_36() { [(); closure!{}] }
+    fn repeat_37() { [(); { closure!{} }] }
+
+    // A repeat expr whose macro expansion is empty
+    fn repeat_38() { [(); empty!{}] }
+    fn repeat_39() { [(); { empty!{} }] }
+}
+
+#[rustfmt::skip]
+mod repeat_square_call {
+    // A repeat expr where the expanded result is a `Res::Err`
+    fn repeat_0() { [(); unbraced_unbraced_ident![]]; }
+    fn repeat_1() { [(); braced_unbraced_ident![]]; }
+    fn repeat_2() { [(); unbraced_braced_ident![]]; }
+    fn repeat_3() { [(); braced_braced_ident![]]; }
+    fn repeat_4() { [(); { unbraced_unbraced_ident![] }]; }
+    fn repeat_5() { [(); { braced_unbraced_ident![] }]; }
+    fn repeat_6() { [(); { unbraced_braced_ident![] }]; }
+    fn repeat_7() { [(); { braced_braced_ident![] }]; }
+    fn repeat_8() { [(); unbraced_ident![]]; }
+    fn repeat_9() { [(); braced_ident![]]; }
+    fn repeat_10() { [(); { unbraced_ident![] }]; }
+    fn repeat_11() { [(); { braced_ident![] }]; }
+
+    // A repeat expr where the expanded result is a `Res::ConstParam`
+    fn repeat_12<const ident: usize>() { [(); unbraced_unbraced_ident![]]; }
+    fn repeat_13<const ident: usize>() { [(); braced_unbraced_ident![]]; }
+    fn repeat_14<const ident: usize>() { [(); unbraced_braced_ident![]]; }
+    fn repeat_15<const ident: usize>() { [(); braced_braced_ident![]]; }
+    fn repeat_16<const ident: usize>() { [(); { unbraced_unbraced_ident![] }]; }
+    fn repeat_17<const ident: usize>() { [(); { braced_unbraced_ident![] }]; }
+    fn repeat_18<const ident: usize>() { [(); { unbraced_braced_ident![] }]; }
+    fn repeat_19<const ident: usize>() { [(); { braced_braced_ident![] }]; }
+    fn repeat_20<const ident: usize>() { [(); unbraced_ident![]]; }
+    fn repeat_21<const ident: usize>() { [(); braced_ident![]]; }
+    fn repeat_22<const ident: usize>() { [(); { unbraced_ident![] }]; }
+    fn repeat_23<const ident: usize>() { [(); { braced_ident![] }]; }
+
+    // A repeat expr where the expanded result is a complex expr
+    fn repeat_24() { [(); unbraced_unbraced_expr![]]; }
+    fn repeat_25() { [(); braced_unbraced_expr![]]; }
+    fn repeat_26() { [(); unbraced_braced_expr![]]; }
+    fn repeat_27() { [(); braced_braced_expr![]]; }
+    fn repeat_28() { [(); { unbraced_unbraced_expr![] }]; }
+    fn repeat_29() { [(); { braced_unbraced_expr![] }]; }
+    fn repeat_30() { [(); { unbraced_braced_expr![] }]; }
+    fn repeat_31() { [(); { braced_braced_expr![] }]; }
+    fn repeat_32() { [(); unbraced_expr![]]; }
+    fn repeat_33() { [(); braced_expr![]]; }
+    fn repeat_34() { [(); { unbraced_expr![] }]; }
+    fn repeat_35() { [(); { braced_expr![] }]; }
+
+    // A repeat expr whose expanded form contains a nested definition
+    fn repeat_36() { [(); closure![]] }
+    fn repeat_37() { [(); { closure![] }] }
+
+    // A repeat expr whose macro expansion is empty
+    fn repeat_38() { [(); empty![]] }
+    fn repeat_39() { [(); { empty![] }] }
 }
 
 fn main() {}
diff --git a/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-3-pass.rs b/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-3-pass.rs
new file mode 100644
index 00000000000..fb6190324c6
--- /dev/null
+++ b/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-3-pass.rs
@@ -0,0 +1,46 @@
+// Additional checks for macro expansion in const args
+
+//@ check-pass
+
+macro_rules! closure {
+    () => { |()| () };
+}
+
+macro_rules! indir_semi {
+    ($nested:ident) => { $nested!(); };
+}
+
+macro_rules! indir {
+    ($nested:ident) => { $nested!() };
+}
+
+macro_rules! empty {
+    () => {};
+}
+
+macro_rules! arg {
+    () => { N };
+}
+
+struct Adt<const N: usize>;
+
+fn array1() -> [(); { closure!(); 0 }] { loop {} }
+fn array2() -> [(); { indir!(closure); 0}] { loop {} }
+fn array3() -> [(); { indir_semi!{ closure } 0 }] { loop {} }
+fn array4<const N: usize>() -> [(); { indir!{ empty } arg!{} }] { loop {} }
+fn array5<const N: usize>() -> [(); { empty!{} arg!() }] { loop {} }
+fn array6<const N: usize>() -> [(); { empty!{} N }] { loop {} }
+fn array7<const N: usize>() -> [(); { arg!{} empty!{} }] { loop {} }
+fn array8<const N: usize>() -> [(); { empty!{} arg!{} empty!{} }] { loop {} }
+
+fn adt1() -> Adt<{ closure!(); 0 }> { loop {} }
+fn adt2() -> Adt<{ indir!(closure); 0}> { loop {} }
+fn adt3() -> Adt<{ indir_semi!{ closure } 0 }> { loop {} }
+fn adt4<const N: usize>() -> Adt<{ indir!{ empty } arg!{} }> { loop {} }
+fn adt5<const N: usize>() -> Adt<{ empty!{} arg!() }> { loop {} }
+fn adt6<const N: usize>() -> Adt<{ empty!{} N }> { loop {} }
+fn adt7<const N: usize>() -> Adt<{ arg!{} empty!{} }> { loop {} }
+fn adt8<const N: usize>() -> Adt<{ empty!{} arg!{} empty!{} }> { loop {} }
+
+
+fn main() {}
diff --git a/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-4.rs b/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-4.rs
new file mode 100644
index 00000000000..3353d6cf2da
--- /dev/null
+++ b/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-4.rs
@@ -0,0 +1,18 @@
+macro_rules! empty {
+    () => {};
+}
+
+macro_rules! arg {
+    () => {
+        N
+        //~^ ERROR generic parameters may not be used in const operations
+        //~| ERROR generic parameters may not be used in const operations
+    };
+}
+
+struct Foo<const N: usize>;
+fn foo<const N: usize>() -> Foo<{ arg!{} arg!{} }> { loop {} }
+fn bar<const N: usize>() -> [(); { empty!{}; N }] { loop {} }
+//~^ ERROR generic parameters may not be used in const operations
+
+fn main() {}
diff --git a/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-4.stderr b/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-4.stderr
new file mode 100644
index 00000000000..4722968b203
--- /dev/null
+++ b/tests/ui/const-generics/early/const_arg_trivial_macro_expansion-4.stderr
@@ -0,0 +1,37 @@
+error: generic parameters may not be used in const operations
+  --> $DIR/const_arg_trivial_macro_expansion-4.rs:7:9
+   |
+LL |         N
+   |         ^ cannot perform const operation using `N`
+...
+LL | fn foo<const N: usize>() -> Foo<{ arg!{} arg!{} }> { loop {} }
+   |                                   ------ in this macro invocation
+   |
+   = help: const parameters may only be used as standalone arguments, i.e. `N`
+   = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = note: this error originates in the macro `arg` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: generic parameters may not be used in const operations
+  --> $DIR/const_arg_trivial_macro_expansion-4.rs:7:9
+   |
+LL |         N
+   |         ^ cannot perform const operation using `N`
+...
+LL | fn foo<const N: usize>() -> Foo<{ arg!{} arg!{} }> { loop {} }
+   |                                          ------ in this macro invocation
+   |
+   = help: const parameters may only be used as standalone arguments, i.e. `N`
+   = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = note: this error originates in the macro `arg` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: generic parameters may not be used in const operations
+  --> $DIR/const_arg_trivial_macro_expansion-4.rs:15:46
+   |
+LL | fn bar<const N: usize>() -> [(); { empty!{}; N }] { loop {} }
+   |                                              ^ cannot perform const operation using `N`
+   |
+   = help: const parameters may only be used as standalone arguments, i.e. `N`
+   = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
+
+error: aborting due to 3 previous errors
+