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
Ag1()20 int A::C::Ag1() { return 0; }
21
Ag2()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 does not match because it is not const qualified}}
31
32 void f(const int& parm); // expected-note{{type of 1st parameter of member declaration does not match definition ('const int &' vs 'int')}}
33 void f(int) const; // expected-note{{member declaration does not match because it is const qualified}}
34 void f(float);
35
36 int x;
37 };
38
m() const39 void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'C2'}}
40
f(int)41 void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'C2'}}
42
m()43 void C2::m() {
44 x = 0;
45 }
46
47 namespace B {
Af()48 void ::A::Af() {} // expected-error {{cannot define or redeclare 'Af' here because namespace 'B' does not enclose namespace 'A'}}
49 }
50
f1()51 void f1() {
52 void A::Af(); // expected-error {{definition or redeclaration of 'Af' not allowed inside a function}}
53 }
54
f2()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 {
mA2::CC::NC82 void m() {}
83 };
84
f3()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
98 typedef void C2::f5(int); // expected-error{{typedef declarator cannot be qualified}}
99
100 void f6(int A2::RC::x); // expected-error{{parameter declarator cannot be qualified}}
101
102 int A2::RC::x; // expected-error{{non-static data member defined out-of-line}}
103
104 void A2::CC::NC::m(); // expected-error{{out-of-line declaration of a member must be a definition}}
105
106
107 namespace E {
108 int X = 5;
109
110 namespace Nested {
111 enum E {
112 X = 0
113 };
114
f()115 void f() {
116 return E::X; // expected-error{{expected a class or namespace}}
117 }
118 }
119 }
120
121
122 class Operators {
123 Operators operator+(const Operators&) const; // expected-note{{member declaration does not match because it is const qualified}}
124 operator bool();
125 };
126
operator +(const Operators &)127 Operators Operators::operator+(const Operators&) { // expected-error{{out-of-line definition of 'operator+' does not match any declaration in 'Operators'}}
128 Operators ops;
129 return ops;
130 }
131
operator +(const Operators &) const132 Operators Operators::operator+(const Operators&) const {
133 Operators ops;
134 return ops;
135 }
136
operator bool()137 Operators::operator bool() {
138 return true;
139 }
140
141 namespace A {
142 void g(int&); // expected-note{{type of 1st parameter of member declaration does not match definition ('int &' vs 'const int &')}}
143 }
144
f()145 void A::f() {} // expected-error-re{{out-of-line definition of 'f' does not match any declaration in namespace 'A'$}}
146
g(const int &)147 void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}}
148
149 struct Struct { };
150
f()151 void Struct::f() { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'Struct'}}
152
153 void global_func(int);
154 void global_func2(int);
155
156 namespace N {
global_func(int)157 void ::global_func(int) { } // expected-error{{definition or redeclaration of 'global_func' cannot name the global scope}}
158
159 void f();
160 // FIXME: if we move this to a separate definition of N, things break!
161 }
global_func2(int)162 void ::global_func2(int) { } // expected-error{{extra qualification on member 'global_func2'}}
163
f()164 void N::f() { } // okay
165
166 struct Y; // expected-note{{forward declaration of 'Y'}}
167 Y::foo y; // expected-error{{incomplete type 'Y' named in nested name specifier}}
168
X()169 X::X() : a(5) { } // expected-error{{use of undeclared identifier 'X'}} \
170 // expected-error{{C++ requires a type specifier for all declarations}} \
171 // expected-error{{only constructors take base initializers}}
172
173 struct foo_S {
174 static bool value;
175 };
176 bool (foo_S::value);
177
178
179 namespace somens {
180 struct a { }; // expected-note{{candidate constructor (the implicit copy constructor)}}
181 }
182
183 template <typename T>
184 class foo {
185 };
186
187
188 // PR4452 / PR4451
189 foo<somens:a> a2; // expected-error {{unexpected ':' in nested name specifier}}
190
191 somens::a a3 = a2; // expected-error {{no viable conversion}}
192
193 // typedefs and using declarations.
194 namespace test1 {
195 namespace ns {
196 class Counter { public: static int count; };
197 typedef Counter counter;
198 }
199 using ns::counter;
200
201 class Test {
test1()202 void test1() {
203 counter c;
204 c.count++;
205 counter::count++;
206 }
207 };
208 }
209
210 // We still need to do lookup in the lexical scope, even if we push a
211 // non-lexical scope.
212 namespace test2 {
213 namespace ns {
214 extern int *count_ptr;
215 }
216 namespace {
217 int count = 0;
218 }
219
220 int *ns::count_ptr = &count;
221 }
222
223 // PR6259, invalid case
224 namespace test3 {
225 class A; // expected-note {{forward declaration}}
foo(const char * path)226 void foo(const char *path) {
227 A::execute(path); // expected-error {{incomplete type 'test3::A' named in nested name specifier}}
228 }
229 }
230
231 namespace PR7133 {
232 namespace A {
233 class Foo;
234 }
235
236 namespace A {
237 namespace B {
238 bool foo(Foo &);
239 }
240 }
241
foo(Foo &)242 bool A::B::foo(Foo &) {
243 return false;
244 }
245 }
246
247 class CLASS {
248 void CLASS::foo2(); // expected-error {{extra qualification on member 'foo2'}}
249 };
250
251 namespace PR8159 {
252 class B { };
253
254 class A {
255 int A::a; // expected-error{{extra qualification on member 'a'}}
256 static int A::b; // expected-error{{extra qualification on member 'b'}}
257 int ::c; // expected-error{{non-friend class member 'c' cannot have a qualified name}}
258 };
259 }
260
261 namespace rdar7980179 {
262 class A { void f0(); }; // expected-note {{previous}}
f0()263 int A::f0() {} // expected-error {{out-of-line definition of 'rdar7980179::A::f0' differs from the declaration in the return type}}
264 }
265
266 namespace alias = A;
267 double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}}
268
269 // http://llvm.org/PR10109
270 namespace PR10109 {
271 template<typename T>
272 struct A {
273 protected:
274 struct B;
275 struct B::C; // expected-error {{requires a template parameter list}} \
276 // expected-error {{no struct named 'C'}} \
277 // expected-error{{non-friend class member 'C' cannot have a qualified name}}
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 }
288
289 namespace PR13033 {
290 namespace NS {
291 int a; // expected-note {{'NS::a' declared here}}
292 int longer_b; //expected-note {{'NS::longer_b' declared here}}
293 }
294
295 // Suggest adding a namespace qualifier to both variable names even though one
296 // is only a single character long.
297 int foobar = a + longer_b; // expected-error {{use of undeclared identifier 'a'; did you mean 'NS::a'?}} \
298 // expected-error {{use of undeclared identifier 'longer_b'; did you mean 'NS::longer_b'?}}
299 }
300