test/SemaCXX/nested-name-spec.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify %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;
  12   void Af();
  13 }
  14
  15 A:: ; // expected-error {{expected unqualified-id}}
  16 // FIXME: there is a member 'ax'; it's just not a class.
  17 ::A::ax::undef ex3; // expected-error {{no member named 'ax'}}
  18 A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}}
  19
  20 int A::C::Ag1() { return 0; }
  21
  22 static int A::C::Ag2() { return 0; } // expected-error{{'static' can}}
  23
  24 int A::C::cx = 17;
  25
  26
  27 static int A::C::cx2 = 17; // expected-error{{'static' can}}
  28
  29 class C2 {
  30   void m(); // expected-note{{member declaration nearly matches}}
  31
  32   void f(const int& parm); // expected-note{{member declaration nearly matches}}
  33   void f(int) const; // expected-note{{member declaration nearly matches}}
  34   void f(float);
  35
  36   int x;
  37 };
  38
  39 void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'C2'}}
  40
  41 void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'C2'}}
  42
  43 void C2::m() {
  44   x = 0;
  45 }
  46
  47 namespace B {
  48   void ::A::Af() {} // expected-error {{definition or redeclaration of 'Af' not in a namespace enclosing 'A'}}
  49 }
  50
  51 void f1() {
  52   void A::Af(); // expected-error {{definition or redeclaration of 'Af' not allowed inside a function}}
  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   int N;
  88   N::x = 0; // expected-error {{expected a class or namespace}}
  89   { int A;           A::ax = 0; }
  90   { typedef int A;   A::ax = 0; } // expected-error{{expected a class or namespace}}
  91   { typedef A::C A;  A::ax = 0; } // expected-error {{no member named 'ax'}}
  92   { typedef A::C A;  A::cx = 0; }
  93 }
  94
  95 // make sure the following doesn't hit any asserts
  96 void f4(undef::C); // expected-error {{use of undeclared identifier 'undef'}} \
  97                       expected-error {{variable has incomplete type 'void'}}
  98
  99 typedef void C2::f5(int); // expected-error{{typedef declarator cannot be qualified}}
 100
 101 void f6(int A2::RC::x); // expected-error{{parameter declarator cannot be qualified}}
 102
 103 int A2::RC::x; // expected-error{{non-static data member defined out-of-line}}
 104
 105 void A2::CC::NC::m(); // expected-error{{out-of-line declaration of a member must be a definition}}
 106
 107
 108 namespace E {
 109   int X = 5;
 110
 111   namespace Nested {
 112     enum E {
 113       X = 0
 114     };
 115
 116     void f() {
 117       return E::X; // expected-error{{expected a class or namespace}}
 118     }
 119   }
 120 }
 121
 122
 123 class Operators {
 124   Operators operator+(const Operators&) const; // expected-note{{member declaration nearly matches}}
 125   operator bool();
 126 };
 127
 128 Operators Operators::operator+(const Operators&) { // expected-error{{out-of-line definition of 'operator+' does not match any declaration in 'Operators'}}
 129   Operators ops;
 130   return ops;
 131 }
 132
 133 Operators Operators::operator+(const Operators&) const {
 134   Operators ops;
 135   return ops;
 136 }
 137
 138 Operators::operator bool() {
 139   return true;
 140 }
 141
 142 namespace A {
 143   void g(int&); // expected-note{{member declaration nearly matches}}
 144 }
 145
 146 void A::f() {} // expected-error{{out-of-line definition of 'f' does not match any declaration in namespace 'A'}}
 147
 148 void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}}
 149
 150 struct Struct { };
 151
 152 void Struct::f() { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'Struct'}}
 153
 154 void global_func(int);
 155 void global_func2(int);
 156
 157 namespace N {
 158   void ::global_func(int) { } // expected-error{{definition or redeclaration of 'global_func' cannot name the global scope}}
 159
 160   void f();
 161   // FIXME: if we move this to a separate definition of N, things break!
 162 }
 163 void ::global_func2(int) { } // expected-error{{definition or redeclaration of 'global_func2' cannot name the global scope}}
 164
 165 void N::f() { } // okay
 166
 167 struct Y;  // expected-note{{forward declaration of 'Y'}}
 168 Y::foo y; // expected-error{{incomplete type 'Y' named in nested name specifier}}
 169
 170 X::X() : a(5) { } // expected-error{{use of undeclared identifier 'X'}} \
 171       // expected-error{{C++ requires a type specifier for all declarations}} \
 172       // expected-error{{only constructors take base initializers}}
 173
 174 struct foo_S {
 175   static bool value;
 176 };
 177 bool (foo_S::value);
 178
 179
 180 namespace somens {
 181   struct a { }; // expected-note{{candidate constructor (the implicit copy constructor)}}
 182 }
 183
 184 template <typename T>
 185 class foo {
 186 };
 187
 188
 189 // PR4452 / PR4451
 190 foo<somens:a> a2;  // expected-error {{unexpected ':' in nested name specifier}}
 191
 192 somens::a a3 = a2; // expected-error {{no viable conversion}}
 193
 194 // typedefs and using declarations.
 195 namespace test1 {
 196   namespace ns {
 197     class Counter { public: static int count; };
 198     typedef Counter counter;
 199   }
 200   using ns::counter;
 201
 202   class Test {
 203     void test1() {
 204       counter c;
 205       c.count++;
 206       counter::count++;
 207     }
 208   };
 209 }
 210
 211 // We still need to do lookup in the lexical scope, even if we push a
 212 // non-lexical scope.
 213 namespace test2 {
 214   namespace ns {
 215     extern int *count_ptr;
 216   }
 217   namespace {
 218     int count = 0;
 219   }
 220
 221   int *ns::count_ptr = &count;
 222 }
 223
 224 // PR6259, invalid case
 225 namespace test3 {
 226   class A; // expected-note {{forward declaration}}
 227   void foo(const char *path) {
 228     A::execute(path); // expected-error {{incomplete type 'test3::A' named in nested name specifier}}
 229   }
 230 }
 231
 232 namespace PR7133 {
 233   namespace A {
 234     class Foo;
 235   }
 236
 237   namespace A {
 238     namespace B {
 239       bool foo(Foo &);
 240     }
 241   }
 242
 243   bool A::B::foo(Foo &) {
 244     return false;
 245   }
 246 }
 247
 248 class CLASS {
 249   void CLASS::foo2(); // expected-warning {{extra qualification on member 'foo2'}}
 250 };
 251
 252 namespace PR8159 {
 253   class B { };
 254
 255   class A {
 256     int A::a; // expected-warning{{extra qualification on member 'a'}}
 257     static int A::b; // expected-warning{{extra qualification on member 'b'}}
 258     int ::c; // expected-error{{non-friend class member 'c' cannot have a qualified name}}
 259   };
 260 }
 261
 262 namespace rdar7980179 {
 263   class A { void f0(); }; // expected-note {{previous}}
 264   int A::f0() {} // expected-error {{out-of-line definition of 'rdar7980179::A::f0' differ from the declaration in the return type}}
 265 }
 266
 267 namespace alias = A;
 268 double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}}
 269
 270 // http://llvm.org/PR10109
 271 namespace PR10109 {
 272 template<typename T>
 273 struct A {
 274 protected:
 275   struct B;
 276   struct B::C; // expected-error {{requires a template parameter list}} \
 277                // expected-error {{no struct named 'C'}}
 278 };
 279
 280 template<typename T>
 281 struct A2 {
 282 protected:
 283   struct B;
 284 };
 285 template <typename T>
 286 struct A2<T>::B::C; // expected-error {{no struct named 'C'}}
 287 }