clang/test/SemaCXX/nested-name-spec.cpp

   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
  19 int A::C::Ag1() { return 0; }
  20
  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
  38 void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'C2'}}
  39
  40 void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'C2'}}
  41
  42 void C2::m() {
  43   x = 0;
  44 }
  45
  46 namespace B {
  47   void ::A::Af() {} // expected-error {{cannot define or redeclare 'Af' here because namespace 'B' does not enclose namespace 'A'}}
  48 }
  49
  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
  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 {
  82   void m() {}
  83 };
  84
  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
 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
 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
 135 Operators Operators::operator+(const Operators&) const {
 136   Operators ops;
 137   return ops;
 138 }
 139
 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
 148 void A::f() {} // expected-error-re{{out-of-line definition of 'f' does not match any declaration in namespace 'A'{{$}}}}
 149
 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
 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 {
 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 }
 165 void ::global_func2(int) { } // expected-warning{{extra qualification on member 'global_func2'}}
 166
 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'}}
 174 void foo() {
 175   Y::~Y(); // expected-error{{incomplete type 'PR25156::Y' named in nested name specifier}}
 176 }
 177 }
 178
 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 {
 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}}
 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
 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}}
 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 '::'?}}
 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.
 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 }