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 } 476