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