1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 
3 extern "C" { void f(bool); }
4 
5 namespace std {
6   using ::f;
7   inline void f() { return f(true); }
8 }
9 
10 namespace M {
11   void f(float);
12 }
13 
14 namespace N {
15   using M::f;
16   void f(int) { } // expected-note{{previous}}
17 
18   void f(int) { } // expected-error{{redefinition}}
19 }
20 
21 namespace N {
22   void f(double);
23   void f(long);
24 }
25 
26 struct X0 {
27   void operator()(int);
28   void operator()(long);
29 };
30 
31 struct X1 : X0 {
32   // FIXME: give this operator() a 'float' parameter to test overloading
33   // behavior. It currently fails.
34   void operator()();
35   using X0::operator();
36 
37   void test() {
38     (*this)(1);
39   }
40 };
41 
42 struct A { void f(); };
43 struct B : A { };
44 class C : B { using B::f; };
45 
46 // PR5751: Resolve overloaded functions through using decls.
47 namespace O {
48   void f(int i);
49   void f(double d);
50 }
51 namespace P {
52   void f();
53   void g(void (*ptr)(int));
54   using O::f;
55   void test() {
56     f();
57     f(1);
58     void (*f_ptr1)(double) = f;
59     void (*f_ptr2)() = f;
60     g(f);
61   }
62 }
63 
64 // Make sure that ADL can find names brought in by using decls.
65 namespace test0 {
66   namespace ns {
67     class Foo {};
68 
69     namespace inner {
70       void foo(char *); // expected-note {{no known conversion}}
71     }
72 
73     using inner::foo;
74   }
75 
76   void test(ns::Foo *p) {
77     foo(*p); // expected-error {{no matching function for call to 'foo'}}
78   }
79 }
80 
81 // Redeclarations!
82 namespace test1 {
83   namespace ns0 { struct Foo {}; }
84   namespace A { void foo(ns0::Foo *p, int y, int z); }
85   namespace ns2 { using A::foo; }
86   namespace ns1 { struct Bar : ns0::Foo {}; }
87   namespace A { void foo(ns0::Foo *p, int y, int z = 0); } // expected-note {{candidate}}
88   namespace ns1 { using A::foo; }
89   namespace ns2 { struct Baz : ns1::Bar {}; }
90   namespace A { void foo(ns0::Foo *p, int y = 0, int z); }
91 
92   void test(ns2::Baz *p) {
93     foo(p, 0, 0); // okay!
94     foo(p, 0); // should be fine!
95     foo(p); // expected-error {{no matching function}}
96   }
97 }
98 
99 namespace test2 {
100   namespace ns { int foo; }
101   template <class T> using ns::foo; // expected-error {{cannot template a using declaration}}
102 
103   // PR8022
104   struct A {
105     template <typename T> void f(T);
106   };
107   class B : A {
108     template <typename T> using A::f<T>; // expected-error {{cannot template a using declaration}}
109   };
110 }
111 
112 // PR8756
113 namespace foo
114 {
115   class Class1; // expected-note{{forward declaration}}
116   class Class2
117   {
118     using ::foo::Class1::Function; // expected-error{{incomplete type 'foo::Class1' named in nested name specifier}}
119   };
120 }
121 
122 // Don't suggest non-typenames for positions requiring typenames.
123 namespace using_suggestion_tyname_val {
124 namespace N { void FFF() {} }
125 using typename N::FFG; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val::N'}}
126 }
127 
128 namespace using_suggestion_member_tyname_val {
129 class CCC { public: void AAA() { } };
130 class DDD : public CCC { public: using typename CCC::AAB; }; // expected-error {{no member named 'AAB' in 'using_suggestion_member_tyname_val::CCC'}}
131 }
132 
133 namespace using_suggestion_tyname_val_dropped_specifier {
134 void FFF() {}
135 namespace N { }
136 using typename N::FFG; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val_dropped_specifier::N'}}
137 }
138 
139 // Currently hints aren't provided to drop out the incorrect M::.
140 namespace using_suggestion_ty_dropped_nested_specifier {
141 namespace N {
142 class AAA {}; // expected-note {{'N::AAA' declared here}}
143 namespace M { }
144 }
145 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'?}}
146 }
147 
148 namespace using_suggestion_tyname_ty_dropped_nested_specifier {
149 namespace N {
150 class AAA {}; // expected-note {{'N::AAA' declared here}}
151 namespace M { }
152 }
153 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'?}}
154 }
155 
156 namespace using_suggestion_val_dropped_nested_specifier {
157 namespace N {
158 void FFF() {} // expected-note {{'N::FFF' declared here}}
159 namespace M { }
160 }
161 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'?}}
162 }
163