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