1 // RUN: %clang_cc1 -verify -fsyntax-only -std=c++2a -pedantic-errors -triple x86_64-linux-gnu %s
2
3 // Make sure we know these are legitimate commas and not typos for ';'.
4 namespace Commas {
5 int a,
6 b [[ ]],
7 c alignas(double);
8 }
9
10 struct S {};
11 enum E { e, };
12
13 auto f() -> struct S {
14 return S();
15 }
16 auto g() -> enum E {
17 return E();
18 }
19
20 namespace EnumBase {
21 enum E {};
22 // PR19810: The ': E' here is not an enum-base, and the ':' is not a typo for '::'.
23 E e = true ? *new enum E : E {};
24 // PR45726: This ':' is not an enum-base.
25 static_assert(_Generic(e, enum E : int{}, int: 1) == 0); // expected-error {{C11 extension}}
26 static_assert(_Generic(1, enum E : int{}, int: 1) == 1); // expected-error {{C11 extension}}
27 }
28
29 namespace OpaqueEnumDecl {
30 enum E : int; // ok
31
32 // PR44941
33 enum E : int n; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
34 typedef enum E : int T; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
35 typedef enum E : int T; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
36 namespace Inner {
37 typedef enum E : int T; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
38 }
39
40 // GCC incorrectly accepts this one
41 using T = enum E : int; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
42
43 // PR19810 comment#2
44 int x[sizeof(enum E : int)]; // expected-error {{non-defining declaration of enumeration with a fixed underlying type is only permitted as a standalone declaration}}
45
46 namespace PR24297 {
47 enum struct E a; // expected-error {{must use 'enum' not 'enum struct'}}
48 enum class F b; // expected-error {{must use 'enum' not 'enum class'}}
49 enum G : int c; // expected-error {{only permitted as a standalone declaration}}
50 enum struct H : int d; // expected-error {{only permitted as a standalone declaration}}
51 enum class I : int e; // expected-error {{only permitted as a standalone declaration}}
52 enum X x; // expected-error {{ISO C++ forbids forward reference}} expected-error {{incomplete}} expected-note {{forward declaration}}
53
54 enum struct E *pa; // expected-error {{must use 'enum' not 'enum struct'}}
55 enum class F *pb; // expected-error {{must use 'enum' not 'enum class'}}
56 enum G : int *pc; // expected-error {{only permitted as a standalone declaration}}
57 enum struct H : int *pd; // expected-error {{only permitted as a standalone declaration}}
58 enum class I : int *pe; // expected-error {{only permitted as a standalone declaration}}
59 enum Y *py; // expected-error {{ISO C++ forbids forward reference}}
60 }
61 }
62
63 int decltype(f())::*ptr_mem_decltype;
64
65 class ExtraSemiAfterMemFn {
66 // Due to a peculiarity in the C++11 grammar, a deleted or defaulted function
67 // is permitted to be followed by either one or two semicolons.
68 void f() = delete // expected-error {{expected ';' after delete}}
69 void g() = delete; // ok
70 void h() = delete;; // ok
71 void i() = delete;;; // expected-error {{extra ';' after member function definition}}
72 };
73
74 int *const const p = 0; // expected-error {{duplicate 'const' declaration specifier}}
75 const const int *q = 0; // expected-error {{duplicate 'const' declaration specifier}}
76
77 struct MultiCV {
78 void f() const const; // expected-error {{duplicate 'const' declaration specifier}}
79 };
80
81 static_assert(something, ""); // expected-error {{undeclared identifier}}
82
83 // PR9903
84 struct SS {
85 typedef void d() = default; // expected-error {{function definition declared 'typedef'}} expected-error {{only special member functions and comparison operators may be defaulted}}
86 };
87
88 using PR14855 = int S::; // expected-error {{expected ';' after alias declaration}}
89
90 // Ensure that 'this' has a const-qualified type in a trailing return type for
91 // a constexpr function.
92 struct ConstexprTrailingReturn {
93 int n;
94 constexpr auto f() const -> decltype((n));
95 };
f() const96 constexpr const int &ConstexprTrailingReturn::f() const { return n; }
97
98 namespace TestIsValidAfterTypeSpecifier {
99 struct s {} v;
100
101 struct s
102 thread_local tl;
103
104 struct s
105 &r0 = v;
106
107 struct s
108 &&r1 = s();
109
110 struct s
111 bitand r2 = v;
112
113 struct s
114 and r3 = s();
115
116 enum E {};
117 enum E
118 [[]] e;
119
120 }
121
122 namespace PR5066 {
123 using T = int (*f)(); // expected-error {{type-id cannot have a name}}
124 template<typename T> using U = int (*f)(); // expected-error {{type-id cannot have a name}}
125 auto f() -> int (*f)(); // expected-error {{only variables can be initialized}} expected-error {{expected ';'}}
126 auto g = []() -> int (*f)() {}; // expected-error {{type-id cannot have a name}}
127 }
128
129 namespace FinalOverride {
130 struct Base {
131 virtual void *f();
132 virtual void *g();
133 virtual void *h();
134 virtual void *i();
135 };
136 struct Derived : Base {
137 virtual auto f() -> void *final;
138 virtual auto g() -> void *override;
139 virtual auto h() -> void *final override;
140 virtual auto i() -> void *override final;
141 };
142 }
143
144 namespace UsingDeclAttrs {
145 using T __attribute__((aligned(1))) = int;
146 using T [[gnu::aligned(1)]] = int;
147 static_assert(alignof(T) == 1, "");
148
149 using [[gnu::aligned(1)]] T = int; // expected-error {{an attribute list cannot appear here}}
150 using T = int [[gnu::aligned(1)]]; // expected-error {{'aligned' attribute cannot be applied to types}}
151 }
152
153 namespace DuplicateSpecifier {
154 constexpr constexpr int f(); // expected-error {{duplicate 'constexpr' declaration specifier}}
155 constexpr int constexpr a = 0; // expected-error {{duplicate 'constexpr' declaration specifier}}
156
157 struct A {
158 friend constexpr int constexpr friend f(); // expected-warning {{duplicate 'friend' declaration specifier}} \
159 // expected-error {{duplicate 'constexpr' declaration specifier}}
160 friend struct A friend; // expected-warning {{duplicate 'friend'}} expected-error {{'friend' must appear first}}
161 };
162
163 constinit constexpr int n1 = 0; // expected-error {{cannot combine with previous 'constinit'}}
164 constexpr constinit int n2 = 0; // expected-error {{cannot combine with previous 'constexpr'}}
165 constinit constinit int n3 = 0; // expected-error {{duplicate 'constinit' declaration specifier}}
166
167 consteval constexpr int f1(); // expected-error {{cannot combine with previous 'consteval'}}
168 constexpr consteval int f2(); // expected-error {{cannot combine with previous 'constexpr'}}
169 consteval consteval int f3(); // expected-error {{duplicate 'consteval' declaration specifier}}
170
171 constinit consteval int wat = 0; // expected-error {{cannot combine with previous 'constinit'}}
172 consteval constinit int huh(); // expected-error {{cannot combine with previous 'consteval'}}
173 }
174
175 namespace ColonColonDecltype {
176 struct S { struct T {}; };
177 ::decltype(S())::T invalid; // expected-error {{expected unqualified-id}}
178 }
179
180 namespace AliasDeclEndLocation {
181 template<typename T> struct A {};
182 // Ensure that we correctly determine the end of this declaration to be the
183 // end of the annotation token, not the beginning.
184 using B = AliasDeclEndLocation::A<int
185 > // expected-error {{expected ';' after alias declaration}}
186 +;
187 using C = AliasDeclEndLocation::A<int
188 >\
189 > // expected-error {{expected ';' after alias declaration}}
190 ;
191 using D = AliasDeclEndLocation::A<int
192 > // expected-error {{expected ';' after alias declaration}}
193 // FIXME: After splitting this >> into two > tokens, we incorrectly determine
194 // the end of the template-id to be after the *second* '>'.
195 using E = AliasDeclEndLocation::A<int>>;
196 #define GGG >>>
197 using F = AliasDeclEndLocation::A<int GGG;
198 // expected-error@-1 {{expected ';' after alias declaration}}
199 B something_else;
200 }
201
202 class PR47176 {
f(PR47176,int=0)203 friend void f(PR47176, int = 0) noexcept(true) {}
204 };
205 static_assert(noexcept(f(PR47176())), "");
206
207 struct Base { virtual void f() = 0; virtual void g() = 0; virtual void h() = 0; };
208 struct MemberComponentOrder : Base {
fMemberComponentOrder209 void f() override __asm__("foobar") __attribute__(( )) {}
210 void g() __attribute__(( )) override;
hMemberComponentOrder211 void h() __attribute__(( )) override {}
212 };
213
214 void NoMissingSemicolonHere(struct S
215 [3]);
216 template<int ...N> void NoMissingSemicolonHereEither(struct S
217 ... [N]);
218
219 // This must be at the end of the file; we used to look ahead past the EOF token here.
220 // expected-error@+1 {{expected unqualified-id}} expected-error@+1{{expected ';'}}
221 using
222