1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
3
4 extern "C" { void f(bool); }
5
6 namespace std {
7 using ::f;
f()8 inline void f() { return f(true); }
9 }
10
11 namespace M {
12 void f(float);
13 }
14
15 namespace N {
16 using M::f;
f(int)17 void f(int) { } // expected-note{{previous}}
18
f(int)19 void f(int) { } // expected-error{{redefinition}}
20 }
21
22 namespace N {
23 void f(double);
24 void f(long);
25 }
26
27 struct X0 {
28 void operator()(int);
29 void operator()(long);
30 };
31
32 struct X1 : X0 {
33 void operator()(float&);
34 using X0::operator();
35
testX136 void test() {
37 (*this)(1);
38 }
39 };
40
41 struct A { void f(); };
42 struct B : A { };
43 class C : B { using B::f; };
44
45 // PR5751: Resolve overloaded functions through using decls.
46 namespace O {
47 void f(int i);
48 void f(double d);
49 }
50 namespace P {
51 void f();
52 void g(void (*ptr)(int));
53 using O::f;
test()54 void test() {
55 f();
56 f(1);
57 void (*f_ptr1)(double) = f;
58 void (*f_ptr2)() = f;
59 g(f);
60 }
61 }
62
63 // Make sure that ADL can find names brought in by using decls.
64 namespace test0 {
65 namespace ns {
66 class Foo {};
67
68 namespace inner {
69 void foo(char *); // expected-note {{no known conversion}}
70 }
71
72 using inner::foo;
73 }
74
test(ns::Foo * p)75 void test(ns::Foo *p) {
76 foo(*p); // expected-error {{no matching function for call to 'foo'}}
77 }
78 }
79
80 // Redeclarations!
81 namespace test1 {
82 namespace ns0 { struct Foo {}; }
83 namespace A { void foo(ns0::Foo *p, int y, int z); }
84 namespace ns2 { using A::foo; }
85 namespace ns1 { struct Bar : ns0::Foo {}; }
86 namespace A { void foo(ns0::Foo *p, int y, int z = 0); } // expected-note {{candidate}}
87 namespace ns1 { using A::foo; }
88 namespace ns2 { struct Baz : ns1::Bar {}; }
89 namespace A { void foo(ns0::Foo *p, int y = 0, int z); }
90
test(ns2::Baz * p)91 void test(ns2::Baz *p) {
92 foo(p, 0, 0); // okay!
93 foo(p, 0); // should be fine!
94 foo(p); // expected-error {{no matching function}}
95 }
96 }
97
98 namespace test2 {
99 namespace ns { int foo; }
100 template <class T> using ns::foo; // expected-error {{cannot template a using declaration}}
101
102 // PR8022
103 struct A {
104 template <typename T> void f(T);
105 };
106 class B : A {
107 template <typename T> using A::f<T>; // expected-error {{cannot template a using declaration}}
108 };
109 }
110
111 // PR8756
112 namespace foo
113 {
114 class Class1; // expected-note{{forward declaration}}
115 class Class2
116 {
117 using ::foo::Class1::Function; // expected-error{{incomplete type 'foo::Class1' named in nested name specifier}}
118 };
119 }
120
121 // Don't suggest non-typenames for positions requiring typenames.
122 namespace using_suggestion_tyname_val {
FFF()123 namespace N { void FFF() {} }
124 using typename N::FFG; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val::N'}}
125 }
126
127 namespace using_suggestion_member_tyname_val {
AAA()128 class CCC { public: void AAA() { } };
129 class DDD : public CCC { public: using typename CCC::AAB; }; // expected-error {{no member named 'AAB' in 'using_suggestion_member_tyname_val::CCC'}}
130 }
131
132 namespace using_suggestion_tyname_val_dropped_specifier {
FFF()133 void FFF() {}
134 namespace N { }
135 using typename N::FFG; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val_dropped_specifier::N'}}
136 }
137
138 // Currently hints aren't provided to drop out the incorrect M::.
139 namespace using_suggestion_ty_dropped_nested_specifier {
140 namespace N {
141 class AAA {}; // expected-note {{'N::AAA' declared here}}
142 namespace M { }
143 }
144 using N::M::AAA; // expected-error {{no member named 'AAA' in namespace 'using_suggestion_ty_dropped_nested_specifier::N::M'; did you mean 'N::AAA'?}}
145 }
146
147 namespace using_suggestion_tyname_ty_dropped_nested_specifier {
148 namespace N {
149 class AAA {}; // expected-note {{'N::AAA' declared here}}
150 namespace M { }
151 }
152 using typename N::M::AAA; // expected-error {{no member named 'AAA' in namespace 'using_suggestion_tyname_ty_dropped_nested_specifier::N::M'; did you mean 'N::AAA'?}}
153 }
154
155 namespace using_suggestion_val_dropped_nested_specifier {
156 namespace N {
FFF()157 void FFF() {} // expected-note {{'N::FFF' declared here}}
158 namespace M { }
159 }
160 using N::M::FFF; // expected-error {{no member named 'FFF' in namespace 'using_suggestion_val_dropped_nested_specifier::N::M'; did you mean 'N::FFF'?}}
161 }
162
163 namespace UsingDeclVsHiddenName {
164 namespace A {
165 enum HiddenTag1 {}; // expected-note {{previous use is here}}
166 enum HiddenTag2 {}; // expected-note {{target}}
167 int HiddenFn1; // expected-note {{target}}
168 int HiddenFn2; // expected-note {{target}}
169 int HiddenLocalExtern1;
170 int HiddenLocalExtern2;
171 }
172
173 namespace B {
174 using A::HiddenTag1;
175 using A::HiddenFn1; // expected-note {{using declaration}}
176 using A::HiddenLocalExtern1;
177
178 struct S {
179 friend struct HiddenTag1; // expected-error {{tag type that does not match previous}}
180 friend struct HiddenTag2; // expected-note {{conflicting declaration}}
181 friend void HiddenFn1(); // expected-error {{cannot befriend target of using declaration}}
182 friend void HiddenFn2(); // expected-note {{conflicting declaration}}
fUsingDeclVsHiddenName::B::S183 void f() {
184 // OK, these are not in the scope of namespace B, even though they're
185 // members of the namespace.
186 void HiddenLocalExtern1();
187 void HiddenLocalExtern2();
188 }
189 };
190
191 using A::HiddenTag2; // expected-error {{conflicts with declaration already in scope}}
192 using A::HiddenFn2; // expected-error {{conflicts with declaration already in scope}}
193 using A::HiddenLocalExtern2;
194 }
195 }
196
197 namespace PR19171 {
198 struct Z {
199 Z();
200 };
201
202 typedef struct {
203 Z i;
204 } S;
205
206 struct Y : S {
207 using S::S;
208 #if __cplusplus < 201103L
209 // expected-error@-2 {{no member named 'S' in 'PR19171::S'}}
210 #endif
211 };
212
213 // [namespace.udecl]p3: In a using-declaration used as a member-declaration,
214 // the nested-name-specifier shall name a base class of the class being defined.
215 // If such a using-declaration names a constructor, the nested-name-specifier
216 // shall name a direct base class of the class being defined;
217
218 struct B_blah { };
219 struct C_blah : B_blah { C_blah(int); }; // expected-note 0-1{{declared here}}
220 struct D1 : C_blah {
221 // FIXME: We should be able to correct this in C++11 mode.
222 using B_blah::C_blah; // expected-error-re {{no member named 'C_blah' in 'PR19171::B_blah'{{$}}}}
223 };
224 struct D2 : C_blah {
225 // Somewhat bizarrely, this names the injected-class-name of B_blah within
226 // C_blah, and is valid.
227 using C_blah::B_blah;
228 };
229 struct D3 : C_blah {
230 using C_blah::D_blah;
231 #if __cplusplus < 201103L
232 // expected-error-re@-2 {{no member named 'D_blah' in 'PR19171::C_blah'{{$}}}}
233 #else
234 // expected-error@-4 {{no member named 'D_blah' in 'PR19171::C_blah'; did you mean 'C_blah'?}}
235 #endif
236 };
237 #if __cplusplus >= 201103L
238 D3 d3(0); // ok
239 #endif
240
241 struct E { };
242 struct EE { int EE; };
243 struct F : E {
244 using E::EE; // expected-error-re {{no member named 'EE' in 'PR19171::E'{{$}}}}
245 };
246
247 struct TypoDuplicate { // expected-note 0-4{{here}}
248 TypoDuplicate(int);
249 void foobar(); // expected-note 2{{here}}
250 };
251 struct TypoDuplicateDerived1 : TypoDuplicate {
252 #if __cplusplus >= 201103L
253 using TypoDuplicate::TypoFuplicate; // expected-error {{did you mean 'TypoDuplicate'}} expected-note {{previous}}
254 using TypoDuplicate::TypoDuplicate; // expected-error {{redeclaration}}
255 #endif
256 using TypoDuplicate::goobar; // expected-error {{did you mean 'foobar'}} expected-note {{previous}}
257 using TypoDuplicate::foobar; // expected-error {{redeclaration}}
258 };
259 struct TypoDuplicateDerived2 : TypoDuplicate {
260 #if __cplusplus >= 201103L
261 using TypoFuplicate::TypoDuplicate; // expected-error {{did you mean 'TypoDuplicate'}} expected-note {{previous}}
262 using TypoDuplicate::TypoDuplicate; // expected-error {{redeclaration}}
263 #endif
264 };
265 struct TypoDuplicateDerived3 : TypoDuplicate {
266 #if __cplusplus >= 201103L
267 // FIXME: Don't suggest a correction that would lead to a redeclaration
268 // error here... or at least diagnose the error.
269 using TypoDuplicate::TypoDuplicate;
270 using TypoDuplicate::TypoFuplicate; // expected-error {{did you mean 'TypoDuplicate'}}
271 #endif
272 using TypoDuplicate::foobar;
273 using TypoDuplicate::goobar; // expected-error {{did you mean 'foobar'}}
274 };
275 struct TypoDuplicateDerived4 : TypoDuplicate {
276 #if __cplusplus >= 201103L
277 using TypoDuplicate::TypoDuplicate; // expected-note {{previous}}
278 using TypoFuplicate::TypoDuplicate; // expected-error {{did you mean 'TypoDuplicate'}} expected-error {{redeclaration}}
279 #endif
280 };
281 }
282
283 namespace TypoCorrectTemplateMember {
284 struct A {
285 template<typename T> void foobar(T); // expected-note {{'foobar' declared here}}
286 };
287 struct B : A {
288 using A::goobar; // expected-error {{no member named 'goobar' in 'TypoCorrectTemplateMember::A'; did you mean 'foobar'?}}
289 };
290 }
291
292 namespace use_instance_in_static {
293 struct A { int n; };
294 struct B : A {
295 using A::n;
fuse_instance_in_static::B296 static int f() { return n; } // expected-error {{invalid use of member 'n' in static member function}}
297 };
298 }
299
300 namespace PR24030 {
301 namespace X {
302 class A; // expected-note {{target}}
303 int i; // expected-note {{target}}
304 }
305 namespace Y {
306 using X::A; // expected-note {{using}}
307 using X::i; // expected-note {{using}}
308 class A {}; // expected-error {{conflicts}}
309 int i; // expected-error {{conflicts}}
310 }
311 }
312
313 namespace PR24033 {
314 extern int a; // expected-note 2{{target of using declaration}}
315 void f(); // expected-note 2{{target of using declaration}}
316 struct s; // expected-note 2{{target of using declaration}}
317 enum e {}; // expected-note 2{{target of using declaration}}
318
319 template<typename> extern int vt; // expected-note 2{{target of using declaration}} expected-warning 0-1{{extension}}
320 template<typename> void ft(); // expected-note 2{{target of using declaration}}
321 template<typename> struct st; // expected-note 2{{target of using declaration}}
322
323 namespace X {
324 using PR24033::a; // expected-note {{using declaration}}
325 using PR24033::f; // expected-note {{using declaration}}
326 using PR24033::s; // expected-note {{using declaration}}
327 using PR24033::e; // expected-note {{using declaration}}
328
329 using PR24033::vt; // expected-note {{using declaration}}
330 using PR24033::ft; // expected-note {{using declaration}}
331 using PR24033::st; // expected-note {{using declaration}}
332
333 extern int a; // expected-error {{declaration conflicts with target of using declaration already in scope}}
334 void f(); // expected-error {{declaration conflicts with target of using declaration already in scope}}
335 struct s; // expected-error {{declaration conflicts with target of using declaration already in scope}}
336 enum e {}; // expected-error {{declaration conflicts with target of using declaration already in scope}}
337
338 template<typename> extern int vt; // expected-error {{declaration conflicts with target of using declaration already in scope}} expected-warning 0-1{{extension}}
339 template<typename> void ft(); // expected-error {{declaration conflicts with target of using declaration already in scope}}
340 template<typename> struct st; // expected-error {{declaration conflicts with target of using declaration already in scope}}
341 }
342
343 namespace Y {
344 extern int a; // expected-note {{conflicting declaration}}
345 void f(); // expected-note {{conflicting declaration}}
346 struct s; // expected-note {{conflicting declaration}}
347 enum e {}; // expected-note {{conflicting declaration}}
348
349 template<typename> extern int vt; // expected-note {{conflicting declaration}} expected-warning 0-1{{extension}}
350 template<typename> void ft(); // expected-note {{conflicting declaration}}
351 template<typename> struct st; // expected-note {{conflicting declaration}}
352
353 using PR24033::a; // expected-error {{target of using declaration conflicts with declaration already in scope}}
354 using PR24033::f; // expected-error {{target of using declaration conflicts with declaration already in scope}}
355 using PR24033::s; // expected-error {{target of using declaration conflicts with declaration already in scope}}
356 using PR24033::e; // expected-error {{target of using declaration conflicts with declaration already in scope}}
357
358 using PR24033::vt; // expected-error {{target of using declaration conflicts with declaration already in scope}}
359 using PR24033::ft; // expected-error {{target of using declaration conflicts with declaration already in scope}}
360 using PR24033::st; // expected-error {{target of using declaration conflicts with declaration already in scope}}
361 }
362 }
363
364 namespace field_use {
365 struct A { int field; };
366 struct B : A {
367 // Previously Clang rejected this valid C++11 code because it didn't look
368 // through the UsingShadowDecl.
369 using A::field;
370 #if __cplusplus < 201103L
371 // expected-error@+2 {{invalid use of non-static data member 'field'}}
372 #endif
373 enum { X = sizeof(field) };
374 };
375 }
376
377 namespace tag_vs_var {
378 namespace N {
379 struct X {};
380
381 struct Y {};
382 int Y;
383
384 int Z;
385 }
386 using N::X;
387 using N::Y;
388 using N::Z;
389
390 namespace N {
391 int X;
392
393 struct Z {};
394 }
395 using N::X;
396 using N::Y;
397 using N::Z;
398 }
399