1 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify -fblocks %s
2 namespace A {
3 struct C {
4 static int cx;
5
6 static int cx2;
7
8 static int Ag1();
9 static int Ag2();
10 };
11 int ax; // expected-note {{'ax' declared here}}
12 void Af();
13 }
14
15 A:: ; // expected-error {{expected unqualified-id}}
16 ::A::ax::undef ex3; // expected-error {{'ax' is not a class, namespace, or enumeration}}
17 A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}}
18
Ag1()19 int A::C::Ag1() { return 0; }
20
Ag2()21 static int A::C::Ag2() { return 0; } // expected-error{{'static' can}}
22
23 int A::C::cx = 17;
24
25
26 static int A::C::cx2 = 17; // expected-error{{'static' can}}
27
28 class C2 {
29 void m(); // expected-note{{member declaration does not match because it is not const qualified}}
30
31 void f(const int& parm); // expected-note{{type of 1st parameter of member declaration does not match definition ('const int &' vs 'int')}}
32 void f(int) const; // expected-note{{member declaration does not match because it is const qualified}}
33 void f(float);
34
35 int x;
36 };
37
m() const38 void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'C2'}}
39
f(int)40 void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'C2'}}
41
m()42 void C2::m() {
43 x = 0;
44 }
45
46 namespace B {
Af()47 void ::A::Af() {} // expected-error {{cannot define or redeclare 'Af' here because namespace 'B' does not enclose namespace 'A'}}
48 }
49
f1()50 void f1() {
51 void A::Af(); // expected-error {{definition or redeclaration of 'Af' not allowed inside a function}}
52 void (^x)() = ^{ void A::Af(); }; // expected-error {{definition or redeclaration of 'Af' not allowed inside a block}}
53 }
54
f2()55 void f2() {
56 A:: ; // expected-error {{expected unqualified-id}}
57 A::C::undef = 0; // expected-error {{no member named 'undef'}}
58 ::A::C::cx = 0;
59 int x = ::A::ax = A::C::cx;
60 x = sizeof(A::C);
61 x = sizeof(::A::C::cx);
62 }
63
64 A::C c1;
65 struct A::C c2;
66 struct S : public A::C {};
67 struct A::undef; // expected-error {{no struct named 'undef' in namespace 'A'}}
68
69 namespace A2 {
70 typedef int INT;
71 struct RC;
72 struct CC {
73 struct NC;
74 };
75 }
76
77 struct A2::RC {
78 INT x;
79 };
80
81 struct A2::CC::NC {
mA2::CC::NC82 void m() {}
83 };
84
f3()85 void f3() {
86 N::x = 0; // expected-error {{use of undeclared identifier 'N'}}
87 // FIXME: Consider including the kind of entity that 'N' is ("variable 'N'
88 // declared here", "template 'X' declared here", etc) to help explain what it
89 // is if it's 'not a class, namespace, or scoped enumeration'.
90 int N; // expected-note {{'N' declared here}}
91 N::x = 0; // expected-error {{'N' is not a class, namespace, or enumeration}}
92 { int A; A::ax = 0; }
93 { typedef int A; A::ax = 0; } // expected-error{{'A' (aka 'int') is not a class, namespace, or enumeration}}
94 { typedef A::C A; A::ax = 0; } // expected-error {{no member named 'ax'}}
95 { typedef A::C A; A::cx = 0; }
96 }
97
98 // make sure the following doesn't hit any asserts
99 void f4(undef::C); // expected-error {{use of undeclared identifier 'undef'}}
100
101 typedef void C2::f5(int); // expected-error{{typedef declarator cannot be qualified}}
102
103 void f6(int A2::RC::x); // expected-error{{parameter declarator cannot be qualified}}
104
105 int A2::RC::x; // expected-error{{non-static data member defined out-of-line}}
106
107 void A2::CC::NC::m(); // expected-error{{out-of-line declaration of a member must be a definition}}
108
109
110 namespace E {
111 int X = 5;
112
113 namespace Nested {
114 enum E {
115 X = 0
116 };
117
f()118 int f() {
119 return E::X; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}}
120 }
121 }
122 }
123
124
125 class Operators {
126 Operators operator+(const Operators&) const; // expected-note{{member declaration does not match because it is const qualified}}
127 operator bool();
128 };
129
operator +(const Operators &)130 Operators Operators::operator+(const Operators&) { // expected-error{{out-of-line definition of 'operator+' does not match any declaration in 'Operators'}}
131 Operators ops;
132 return ops;
133 }
134
operator +(const Operators &) const135 Operators Operators::operator+(const Operators&) const {
136 Operators ops;
137 return ops;
138 }
139
operator bool()140 Operators::operator bool() {
141 return true;
142 }
143
144 namespace A {
145 void g(int&); // expected-note{{type of 1st parameter of member declaration does not match definition ('int &' vs 'const int &')}}
146 }
147
f()148 void A::f() {} // expected-error-re{{out-of-line definition of 'f' does not match any declaration in namespace 'A'{{$}}}}
149
g(const int &)150 void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}}
151
152 struct Struct { };
153
f()154 void Struct::f() { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'Struct'}}
155
156 void global_func(int);
157 void global_func2(int);
158
159 namespace N {
global_func(int)160 void ::global_func(int) { } // expected-error{{definition or redeclaration of 'global_func' cannot name the global scope}}
161
162 void f();
163 // FIXME: if we move this to a separate definition of N, things break!
164 }
global_func2(int)165 void ::global_func2(int) { } // expected-warning{{extra qualification on member 'global_func2'}}
166
f()167 void N::f() { } // okay
168
169 struct Y; // expected-note{{forward declaration of 'Y'}}
170 Y::foo y; // expected-error{{incomplete type 'Y' named in nested name specifier}}
171
172 namespace PR25156 {
173 struct Y; // expected-note{{forward declaration of 'PR25156::Y'}}
foo()174 void foo() {
175 Y::~Y(); // expected-error{{incomplete type 'PR25156::Y' named in nested name specifier}}
176 }
177 }
178
X()179 X::X() : a(5) { } // expected-error{{use of undeclared identifier 'X'}}
180
181 struct foo_S {
182 static bool value;
183 };
184 bool (foo_S::value);
185
186
187 namespace somens {
188 struct a { }; // expected-note{{candidate constructor (the implicit copy constructor)}}
189 }
190
191 template <typename T>
192 class foo {
193 };
194
195
196 // PR4452 / PR4451
197 foo<somens:a> a2; // expected-error {{unexpected ':' in nested name specifier}}
198
199 somens::a a3 = a2; // expected-error {{no viable conversion}}
200
201 // typedefs and using declarations.
202 namespace test1 {
203 namespace ns {
204 class Counter { public: static int count; };
205 typedef Counter counter;
206 }
207 using ns::counter;
208
209 class Test {
test1()210 void test1() {
211 counter c;
212 c.count++;
213 counter::count++;
214 }
215 };
216 }
217
218 // We still need to do lookup in the lexical scope, even if we push a
219 // non-lexical scope.
220 namespace test2 {
221 namespace ns {
222 extern int *count_ptr;
223 }
224 namespace {
225 int count = 0;
226 }
227
228 int *ns::count_ptr = &count;
229 }
230
231 // PR6259, invalid case
232 namespace test3 {
233 class A; // expected-note {{forward declaration}}
foo(const char * path)234 void foo(const char *path) {
235 A::execute(path); // expected-error {{incomplete type 'test3::A' named in nested name specifier}}
236 }
237 }
238
239 namespace PR7133 {
240 namespace A {
241 class Foo;
242 }
243
244 namespace A {
245 namespace B {
246 bool foo(Foo &);
247 }
248 }
249
foo(Foo &)250 bool A::B::foo(Foo &) {
251 return false;
252 }
253 }
254
255 class CLASS {
256 void CLASS::foo2(); // expected-error {{extra qualification on member 'foo2'}}
257 };
258
259 namespace PR8159 {
260 class B { };
261
262 class A {
263 int A::a; // expected-error{{extra qualification on member 'a'}}
264 static int A::b; // expected-error{{extra qualification on member 'b'}}
265 int ::c; // expected-error{{non-friend class member 'c' cannot have a qualified name}}
266 };
267 }
268
269 namespace rdar7980179 {
270 class A { void f0(); }; // expected-note {{previous}}
f0()271 int A::f0() {} // expected-error {{return type of out-of-line definition of 'rdar7980179::A::f0' differs}}
272 }
273
274 namespace alias = A;
275 double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}}
276
277 // http://llvm.org/PR10109
278 namespace PR10109 {
279 template<typename T>
280 struct A {
281 protected:
282 struct B;
283 struct B::C; // expected-error {{requires a template parameter list}} \
284 // expected-error {{no struct named 'C'}} \
285 // expected-error{{non-friend class member 'C' cannot have a qualified name}}
286 };
287
288 template<typename T>
289 struct A2 {
290 protected:
291 struct B;
292 };
293 template <typename T>
294 struct A2<T>::B::C; // expected-error {{no struct named 'C'}}
295 }
296
297 namespace PR13033 {
298 namespace NS {
299 int a; // expected-note {{'NS::a' declared here}}
300 int longer_b; //expected-note {{'NS::longer_b' declared here}}
301 }
302
303 // Suggest adding a namespace qualifier to both variable names even though one
304 // is only a single character long.
305 int foobar = a + longer_b; // expected-error {{use of undeclared identifier 'a'; did you mean 'NS::a'?}} \
306 // expected-error {{use of undeclared identifier 'longer_b'; did you mean 'NS::longer_b'?}}
307 }
308
309 // <rdar://problem/13853540>
310 namespace N {
311 struct X { };
312 namespace N {
313 struct Foo {
314 struct N::X *foo(); // expected-error{{no struct named 'X' in namespace 'N::N'}}
315 };
316 }
317 }
318
319 namespace TypedefNamespace { typedef int F; };
320 TypedefNamespace::F::NonexistentName BadNNSWithCXXScopeSpec; // expected-error {{'TypedefNamespace::F' (aka 'int') is not a class, namespace, or enumeration}}
321
322 namespace PR18587 {
323
324 struct C1 {
325 int a, b, c;
326 typedef int C2;
327 struct B1 {
328 struct B2 {
329 int a, b, c;
330 };
331 };
332 };
333 struct C2 { static const unsigned N1 = 1; };
334 struct B1 {
335 enum E1 { B2 = 2 };
336 static const int B3 = 3;
337 };
338 const int N1 = 2;
339
340 // Function declarators
341 struct S1a { int f(C1::C2); };
342 struct S1b { int f(C1:C2); }; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
343
344 struct S2a {
345 C1::C2 f(C1::C2);
346 };
347 struct S2c {
348 C1::C2 f(C1:C2); // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
349 };
350
351 struct S3a {
352 int f(C1::C2), C2 : N1;
353 int g : B1::B2;
354 };
355 struct S3b {
356 int g : B1:B2; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
357 };
358
359 // Inside square brackets
360 struct S4a {
361 int f[C2::N1];
362 };
363 struct S4b {
364 int f[C2:N1]; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
365 };
366
367 struct S5a {
368 int f(int xx[B1::B3 ? C2::N1 : B1::B2]);
369 };
370 struct S5b {
371 int f(int xx[B1::B3 ? C2::N1 : B1:B2]); // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
372 };
373 struct S5c {
374 int f(int xx[B1:B3 ? C2::N1 : B1::B2]); // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
375 };
376
377 // Bit fields
378 struct S6a {
379 C1::C2 m1 : B1::B2;
380 };
381 struct S6c {
382 C1::C2 m1 : B1:B2; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
383 };
384 struct S6d {
385 int C2:N1;
386 };
387 struct S6e {
388 static const int N = 3;
389 B1::E1 : N;
390 };
391 struct S6g {
392 C1::C2 : B1:B2; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
393 B1::E1 : B1:B2; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
394 };
395
396 // Template parameters
397 template <int N> struct T1 {
398 int a,b,c;
399 static const unsigned N1 = N;
400 typedef unsigned C1;
401 };
402 T1<C2::N1> var_1a;
403 T1<C2:N1> var_1b; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
F()404 template<int N> int F() {}
405 int (*X1)() = (B1::B2 ? F<1> : F<2>);
406 int (*X2)() = (B1:B2 ? F<1> : F<2>); // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
407
408 // Bit fields + templates
409 struct S7a {
410 T1<B1::B2>::C1 m1 : T1<B1::B2>::N1;
411 };
412 struct S7b {
413 T1<B1:B2>::C1 m1 : T1<B1::B2>::N1; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
414 };
415 struct S7c {
416 T1<B1::B2>::C1 m1 : T1<B1:B2>::N1; // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
417 };
418
419 }
420
421 namespace PR16951 {
422 namespace ns {
423 enum an_enumeration {
424 ENUMERATOR // expected-note{{'ENUMERATOR' declared here}}
425 };
426 }
427
428 int x1 = ns::an_enumeration::ENUMERATOR; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}}
429
430 int x2 = ns::an_enumeration::ENUMERATOR::vvv; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \
431 // expected-error{{'ENUMERATOR' is not a class, namespace, or enumeration}} \
432
433 int x3 = ns::an_enumeration::X; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \
434 // expected-error{{no member named 'X'}}
435
436 enum enumerator_2 {
437 ENUMERATOR_2
438 };
439
440 int x4 = enumerator_2::ENUMERATOR_2; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}}
441 int x5 = enumerator_2::X2; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \
442 // expected-error{{no member named 'X2' in 'PR16951::enumerator_2'}}
443
444 }
445
446 namespace PR30619 {
447 c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d;
448 // expected-error@-1 16{{unknown type name 'c'}}
449 c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d;
450 // expected-error@-1 16{{unknown type name 'c'}}
451 c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d;
452 // expected-error@-1 16{{unknown type name 'c'}}
453 c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d;
454 // expected-error@-1 16{{unknown type name 'c'}}
455 namespace A {
456 class B {
457 typedef C D; // expected-error{{unknown type name 'C'}}
458 A::D::F;
459 // expected-error@-1{{'PR30619::A::B::D' (aka 'int') is not a class, namespace, or enumeration}}
460 };
461 }
462 }
463
464 namespace DependentTemplateInTrivialNNSLoc {
465 // This testcase causes us to create trivial type source info when doing
466 // substitution into T::template g<>. That trivial type source info contained
467 // a NestedNameSpecifierLoc with no location information.
468 //
469 // Previously, creating a CXXScopeSpec from that resulted in an invalid scope
470 // spec, leading to crashes. Ensure we don't crash here.
f(T & x)471 template <typename T> void f(T &x) {
472 for (typename T::template g<> i : x) {} // expected-warning 0-1{{extension}}
473 x: goto x;
474 }
475 }
476