Clang Project

clang_source_code/test/SemaCXX/nested-name-spec.cpp
1// RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify -fblocks %s 
2namespace 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
15A:: ; // expected-error {{expected unqualified-id}}
16::A::ax::undef ex3; // expected-error {{'ax' is not a class, namespace, or enumeration}}
17A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}}
18
19int A::C::Ag1() { return 0; }
20
21static int A::C::Ag2() { return 0; } // expected-error{{'static' can}}
22
23int A::C::cx = 17;
24
25
26static int A::C::cx2 = 17; // expected-error{{'static' can}}
27
28class 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
38void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'C2'}}
39
40void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'C2'}}
41
42void C2::m() {
43  x = 0;
44}
45
46namespace B {
47  void ::A::Af() {} // expected-error {{cannot define or redeclare 'Af' here because namespace 'B' does not enclose namespace 'A'}}
48}
49
50void 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
55void 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
64A::C c1;
65struct A::C c2;
66struct S : public A::C {};
67struct A::undef; // expected-error {{no struct named 'undef' in namespace 'A'}}
68
69namespace A2 {
70  typedef int INT;
71  struct RC;
72  struct CC {
73    struct NC;
74  };
75}
76
77struct A2::RC {
78  INT x;
79};
80
81struct A2::CC::NC {
82  void m() {}
83};
84
85void 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
99void f4(undef::C); // expected-error {{use of undeclared identifier 'undef'}}
100
101typedef void C2::f5(int); // expected-error{{typedef declarator cannot be qualified}}
102
103void f6(int A2::RC::x); // expected-error{{parameter declarator cannot be qualified}}
104
105int A2::RC::x; // expected-error{{non-static data member defined out-of-line}}
106
107void A2::CC::NC::m(); // expected-error{{out-of-line declaration of a member must be a definition}}
108
109
110namespace E {
111  int X = 5;
112  
113  namespace Nested {
114    enum E {
115      X = 0
116    };
117
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
125class Operators {
126  Operators operator+(const Operators&) const; // expected-note{{member declaration does not match because it is const qualified}}
127  operator bool();
128};
129
130Operators 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
135Operators Operators::operator+(const Operators&) const {
136  Operators ops;
137  return ops;
138}
139
140Operators::operator bool() {
141  return true;
142}
143
144namespace A {
145  void g(int&); // expected-note{{type of 1st parameter of member declaration does not match definition ('int &' vs 'const int &')}}
146} 
147
148void A::f() {} // expected-error-re{{out-of-line definition of 'f' does not match any declaration in namespace 'A'{{$}}}}
149
150void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}}
151
152struct Struct { };
153
154void Struct::f() { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'Struct'}}
155
156void global_func(int);
157void global_func2(int);
158
159namespace N {
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}
165void ::global_func2(int) { } // expected-warning{{extra qualification on member 'global_func2'}}
166
167void N::f() { } // okay
168
169struct Y;  // expected-note{{forward declaration of 'Y'}}
170Y::foo y; // expected-error{{incomplete type 'Y' named in nested name specifier}}
171
172namespace PR25156 {
173struct Y;  // expected-note{{forward declaration of 'PR25156::Y'}}
174void foo() {
175  Y::~Y(); // expected-error{{incomplete type 'PR25156::Y' named in nested name specifier}}
176}
177}
178
179X::X() : a(5) { } // expected-error{{use of undeclared identifier 'X'}}
180
181struct foo_S {
182  static bool value;
183};
184bool (foo_S::value);
185
186
187namespace somens {
188  struct a { }; // expected-note{{candidate constructor (the implicit copy constructor)}}
189}
190
191template <typename T>
192class foo {
193};
194
195
196// PR4452 / PR4451
197foo<somens:a> a2;  // expected-error {{unexpected ':' in nested name specifier}}
198
199somens::a a3 = a2; // expected-error {{no viable conversion}}
200
201// typedefs and using declarations.
202namespace test1 {
203  namespace ns {
204    class Counter { public: static int count; };
205    typedef Counter counter;
206  }
207  using ns::counter;
208
209  class Test {
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.
220namespace 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
232namespace test3 {
233  class A; // expected-note {{forward declaration}}
234  void foo(const char *path) {
235    A::execute(path); // expected-error {{incomplete type 'test3::A' named in nested name specifier}}
236  }
237}
238
239namespace PR7133 {
240  namespace A {
241    class Foo;
242  }
243
244  namespace A {
245    namespace B {
246      bool foo(Foo &);
247    }
248  }
249
250  bool A::B::foo(Foo &) {
251    return false;
252  }
253}
254
255class CLASS {
256  void CLASS::foo2(); // expected-error {{extra qualification on member 'foo2'}}
257};
258
259namespace 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
269namespace rdar7980179 {
270  class A { void f0(); }; // expected-note {{previous}}
271  int A::f0() {} // expected-error {{return type of out-of-line definition of 'rdar7980179::A::f0' differs}}
272}
273
274namespace alias = A;
275double *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
278namespace PR10109 {
279template<typename T>
280struct A {
281protected:
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
288template<typename T>
289struct A2 {
290protected:
291  struct B;
292};
293template <typename T>
294struct A2<T>::B::C; // expected-error {{no struct named 'C'}}
295}
296
297namespace PR13033 {
298namespace 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.
305int 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>
310namespace 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
319namespace TypedefNamespace { typedef int F; };
320TypedefNamespace::F::NonexistentName BadNNSWithCXXScopeSpec; // expected-error {{'TypedefNamespace::F' (aka 'int') is not a class, namespace, or enumeration}}
321
322namespace PR18587 {
323
324struct C1 {
325  int a, b, c;
326  typedef int C2;
327  struct B1 {
328    struct B2 {
329      int a, b, c;
330    };
331  };
332};
333struct C2 { static const unsigned N1 = 1; };
334struct B1 {
335  enum E1 { B2 = 2 };
336  static const int B3 = 3;
337};
338const int N1 = 2;
339
340// Function declarators
341struct S1a { int f(C1::C2); };
342struct S1b { int f(C1:C2); };  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
343
344struct S2a {
345  C1::C2 f(C1::C2);
346};
347struct S2c {
348  C1::C2 f(C1:C2);  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
349};
350
351struct S3a {
352  int f(C1::C2), C2 : N1;
353  int g : B1::B2;
354};
355struct S3b {
356  int g : B1:B2;  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
357};
358
359// Inside square brackets
360struct S4a {
361  int f[C2::N1];
362};
363struct S4b {
364  int f[C2:N1];  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
365};
366
367struct S5a {
368  int f(int xx[B1::B3 ? C2::N1 : B1::B2]);
369};
370struct S5b {
371  int f(int xx[B1::B3 ? C2::N1 : B1:B2]);  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
372};
373struct 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
378struct S6a {
379  C1::C2 m1 : B1::B2;
380};
381struct S6c {
382  C1::C2 m1 : B1:B2;  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
383};
384struct S6d {
385  int C2:N1;
386};
387struct S6e {
388  static const int N = 3;
389  B1::E1 : N;
390};
391struct 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
397template <int N> struct T1 {
398  int a,b,c;
399  static const unsigned N1 = N;
400  typedef unsigned C1;
401};
402T1<C2::N1> var_1a;
403T1<C2:N1> var_1b;  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
404template<int N> int F() {}
405int (*X1)() = (B1::B2 ? F<1> : F<2>);
406int (*X2)() = (B1:B2 ? F<1> : F<2>);  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
407
408// Bit fields + templates
409struct S7a {
410  T1<B1::B2>::C1 m1 : T1<B1::B2>::N1;
411};
412struct S7b {
413  T1<B1:B2>::C1 m1 : T1<B1::B2>::N1;  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
414};
415struct 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
421namespace 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
446namespace PR30619 {
447c 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'}}
449c 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'}}
451c 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'}}
453c 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'}}
455namespace A {
456class 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
CodeThinker, Enjoy your reading code