1 // RUN: %clang_cc1 -fsyntax-only -pedantic -std=c++11 -verify -triple x86_64-apple-darwin %s
2 // RUN: %clang_cc1 -fsyntax-only -pedantic -std=c++17 -verify -triple x86_64-apple-darwin %s
3
4 enum class E1 {
5 Val1 = 1L
6 };
7
8 enum struct E2 {
9 Val1 = '\0'
10 };
11
12 E1 v1 = Val1; // expected-error{{undeclared identifier}}
13 E1 v2 = E1::Val1;
14
15 static_assert(sizeof(E1) == sizeof(int), "bad size");
16 static_assert(sizeof(E1::Val1) == sizeof(int), "bad size");
17 static_assert(sizeof(E2) == sizeof(int), "bad size");
18 static_assert(sizeof(E2::Val1) == sizeof(int), "bad size");
19
20 E1 v3 = E2::Val1; // expected-error{{cannot initialize a variable}}
21 int x1 = E1::Val1; // expected-error{{cannot initialize a variable}}
22
23 enum E3 : char {
24 Val2 = 1
25 };
26
27 E3 v4 = Val2;
28 E1 v5 = Val2; // expected-error{{cannot initialize a variable}}
29
30 static_assert(sizeof(E3) == 1, "bad size");
31
32 int x2 = Val2;
33
34 int a1[Val2];
35 int a2[E1::Val1];
36
37 #if __cplusplus >= 201703L
38 // expected-error@-3 {{type 'E1' is not implicitly convertible to 'unsigned long'}}
39 #else
40 // expected-error@-5 {{size of array has non-integer type}}
41 #endif
42
43 int* p1 = new int[Val2];
44 int* p2 = new int[E1::Val1];
45
46 #if __cplusplus >= 201703L
47 // expected-error@-3 {{converting 'E1' to incompatible type 'unsigned long'}}
48 #else
49 // expected-error@-5 {{array size expression must have integral or unscoped enumeration type, not 'E1'}}
50 #endif
51
52 enum class E4 {
53 e1 = -2147483648, // ok
54 e2 = 2147483647, // ok
55 e3 = 2147483648 // expected-error{{enumerator value evaluates to 2147483648, which cannot be narrowed to type 'int'}}
56 };
57
58 enum class E5 {
59 e1 = 2147483647, // ok
60 e2 // expected-error{{2147483648 is not representable in the underlying}}
61 };
62
63 enum class E6 : bool {
64 e1 = false, e2 = true,
65 e3 // expected-error{{2 is not representable in the underlying}}
66 };
67
68 enum E7 : bool {
69 e1 = false, e2 = true,
70 e3 // expected-error{{2 is not representable in the underlying}}
71 };
72
73 template <class T>
74 struct X {
75 enum E : T {
76 e1, e2,
77 e3 // expected-error{{2 is not representable in the underlying}}
78 };
79 };
80
81 X<bool> X2; // expected-note{{in instantiation of template}}
82
83 enum Incomplete1; // expected-error{{C++ forbids forward references}}
84
85 enum Complete1 : int;
86 Complete1 complete1;
87
88 enum class Complete2;
89 Complete2 complete2;
90
91 // All the redeclarations below are done twice on purpose. Tests that the type
92 // of the declaration isn't changed.
93
94 enum class Redeclare2; // expected-note{{previous declaration is here}} expected-note{{previous declaration is here}}
95 enum Redeclare2; // expected-error{{previously declared as scoped}}
96 enum Redeclare2; // expected-error{{previously declared as scoped}}
97
98 enum Redeclare3 : int; // expected-note{{previous declaration is here}} expected-note{{previous declaration is here}}
99 enum Redeclare3; // expected-error{{previously declared with fixed underlying type}}
100 enum Redeclare3; // expected-error{{previously declared with fixed underlying type}}
101
102 enum class Redeclare5;
103 enum class Redeclare5 : int; // ok
104
105 enum Redeclare6 : int; // expected-note{{previous declaration is here}} expected-note{{previous declaration is here}}
106 enum Redeclare6 : short; // expected-error{{redeclared with different underlying type}}
107 enum Redeclare6 : short; // expected-error{{redeclared with different underlying type}}
108
109 enum class Redeclare7; // expected-note{{previous declaration is here}} expected-note{{previous declaration is here}}
110 enum class Redeclare7 : short; // expected-error{{redeclared with different underlying type}}
111 enum class Redeclare7 : short; // expected-error{{redeclared with different underlying type}}
112
113 enum : long {
114 long_enum_val = 10000
115 };
116
117 enum : long x; // expected-error{{unnamed enumeration must be a definition}} \
118 // expected-warning{{declaration does not declare anything}}
119
PR9333()120 void PR9333() {
121 enum class scoped_enum { yes, no, maybe };
122 scoped_enum e = scoped_enum::yes;
123 if (e == scoped_enum::no) { }
124 }
125
126 // <rdar://problem/9366066>
127 namespace rdar9366066 {
128 enum class X : unsigned { value };
129
f(X x)130 void f(X x) {
131 x % X::value; // expected-error{{invalid operands to binary expression ('rdar9366066::X' and 'rdar9366066::X')}}
132 x % 8; // expected-error{{invalid operands to binary expression ('rdar9366066::X' and 'int')}}
133 }
134 }
135
136 // Part 1 of PR10264
137 namespace test5 {
138 namespace ns {
139 typedef unsigned Atype;
140 enum A : Atype;
141 }
142 enum ns::A : ns::Atype {
143 x, y, z
144 };
145 }
146
147 // Part 2 of PR10264
148 namespace test6 {
149 enum A : unsigned;
150 struct A::a; // expected-error {{incomplete type 'test6::A' named in nested name specifier}}
151 enum A::b; // expected-error {{incomplete type 'test6::A' named in nested name specifier}}
152 int A::c; // expected-error {{incomplete type 'test6::A' named in nested name specifier}}
153 void A::d(); // expected-error {{incomplete type 'test6::A' named in nested name specifier}}
test()154 void test() {
155 (void) A::e; // expected-error {{incomplete type 'test6::A' named in nested name specifier}}
156 }
157 }
158
159 namespace PR11484 {
160 const int val = 104;
161 enum class test1 { owner_dead = val, };
162 }
163
164 namespace N2764 {
165 enum class E *x0a; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
166 enum E2 *x0b; // OK
167 enum class E { a, b };
168 enum E x1 = E::a; // ok
169 enum class E x2 = E::a; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
170
171 enum F { a, b };
172 enum F y1 = a; // ok
173 enum class F y2 = a; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
174
175 struct S {
176 friend enum class E; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
177 friend enum class F; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
178
179 friend enum G {}; // expected-error {{forward reference}} expected-error {{cannot define a type in a friend declaration}}
180 friend enum class H {}; // expected-error {{forward reference}} expected-error {{cannot define a type in a friend declaration}}
181 friend enum I : int {}; // expected-error {{forward reference}} expected-error {{cannot define a type in a friend declaration}}
182
183 enum A : int;
184 A a;
185 } s;
186
187 enum S::A : int {};
188
189 enum class B;
190 }
191
192 enum class N2764::B {};
193
194 namespace PR12106 {
195 template<typename E> struct Enum {
EnumPR12106::Enum196 Enum() : m_e(E::Last) {}
197 E m_e;
198 };
199
200 enum eCOLORS { Last };
201 Enum<eCOLORS> e;
202 }
203
204 namespace test7 {
205 enum class E { e = (struct S*)0 == (struct S*)0 };
206 S *p;
207 }
208
209 namespace test8 {
210 template<typename T> struct S {
211 enum A : int; // expected-note {{here}}
212 enum class B; // expected-note {{here}}
213 enum class C : int; // expected-note {{here}}
214 enum class D : int; // expected-note {{here}}
215 };
216 template<typename T> enum S<T>::A { a }; // expected-error {{previously declared with fixed underlying type}}
217 template<typename T> enum class S<T>::B : char { b }; // expected-error {{redeclared with different underlying}}
218 template<typename T> enum S<T>::C : int { c }; // expected-error {{previously declared as scoped}}
219 template<typename T> enum class S<T>::D : char { d }; // expected-error {{redeclared with different underlying}}
220 }
221
222 namespace test9 {
223 template<typename T> struct S {
224 enum class ET : T; // expected-note 2{{here}}
225 enum class Eint : int; // expected-note 2{{here}}
226 };
227 template<> enum class S<int>::ET : int {};
228 template<> enum class S<char>::ET : short {}; // expected-error {{different underlying type}}
229 template<> enum class S<int>::Eint : short {}; // expected-error {{different underlying type}}
230 template<> enum class S<char>::Eint : int {};
231
232 template<typename T> enum class S<T>::ET : int {}; // expected-error {{different underlying type 'int' (was 'short')}}
233 template<typename T> enum class S<T>::Eint : T {}; // expected-error {{different underlying type 'short' (was 'int')}}
234
235 // The implicit instantiation of S<short> causes the implicit instantiation of
236 // all declarations of member enumerations, so is ill-formed, even though we
237 // never instantiate the definitions of S<short>::ET nor S<short>::Eint.
238 S<short> s; // expected-note {{in instantiation of}}
239 }
240
241 namespace test10 {
f()242 template<typename T> int f() {
243 enum E : int;
244 enum E : T; // expected-note {{here}}
245 E x;
246 enum E : int { e }; // expected-error {{different underlying}}
247 x = e;
248 return x;
249 }
250 int k = f<int>();
251 int l = f<short>(); // expected-note {{here}}
252
g()253 template<typename T> int g() {
254 enum class E : int;
255 enum class E : T; // expected-note {{here}}
256 E x;
257 enum class E : int { e }; // expected-error {{different underlying}}
258 x = E::e;
259 return (int)x;
260 }
261 int m = g<int>();
262 int n = g<short>(); // expected-note {{here}}
263 }
264
265 namespace pr13128 {
266 // This should compile cleanly
267 class C {
268 enum class E { C };
269 };
270 }
271
272 namespace PR15633 {
273 template<typename T> struct A {
274 struct B {
275 enum class E : T;
276 enum class E2 : T;
277 };
278 };
279 template<typename T> enum class A<T>::B::E { e };
280 template class A<int>;
281
282 struct B { enum class E; };
283 template<typename T> enum class B::E { e }; // expected-error {{enumeration cannot be a template}}
284 }
285
286 namespace PR16900 {
287 enum class A;
f(A a)288 A f(A a) { return -a; } // expected-error {{invalid argument type 'PR16900::A' to unary expression}}
289 }
290
291 namespace PR18551 {
292 enum class A { A };
f()293 bool f() { return !A::A; } // expected-error {{invalid argument type 'PR18551::A' to unary expression}}
294 }
295
296 namespace rdar15124329 {
297 enum class B : bool { F, T };
298
299 const rdar15124329::B T1 = B::T;
300 typedef B C; const C T2 = B::T;
301
302 static_assert(T1 != B::F, "");
303 static_assert(T2 == B::T, "");
304 }
305
306 namespace PR18044 {
307 enum class E { a };
308
309 int E::e = 0; // expected-error {{does not refer into a class}}
f()310 void E::f() {} // expected-error {{does not refer into a class}}
311 struct E::S {}; // expected-error {{no struct named 'S'}}
312 struct T : E::S {}; // expected-error {{expected class name}}
313 enum E::E {}; // expected-error {{no enum named 'E'}}
314 int E::*p; // expected-error {{does not point into a class}}
315 using E::f; // expected-error {{no member named 'f'}}
316
317 using E::a; // expected-warning {{using declaration naming a scoped enumerator is a C++20 extension}}
318 E b = a;
319 }
320
321 namespace test11 {
322 enum class E { a };
323 typedef E E2;
f1()324 E2 f1() { return E::a; }
325
f()326 bool f() { return !f1(); } // expected-error {{invalid argument type 'test11::E2' (aka 'test11::E') to unary expression}}
327 }
328
329 namespace PR35586 {
330 enum C { R, G, B };
331 enum B { F = (enum C) -1, T}; // this should compile cleanly, it used to assert.
332 };
333
334 namespace test12 {
335 // Check that clang rejects this code without crashing in c++17.
336 enum class A;
337 enum class B;
338 A a;
339 B b{a}; // expected-error {{cannot initialize}}
340 }
341