1 // RUN: %clang_cc1 -std=c++20 -fsyntax-only %s -verify
2 
3 #define UIE __attribute__((using_if_exists))
4 
5 namespace test_basic {
6 namespace NS {}
7 
8 using NS::x UIE; // expected-note{{using declaration annotated with 'using_if_exists' here}}
9 x usex();        // expected-error{{reference to unresolved using declaration}}
10 
11 using NotNS::x UIE; // expected-error{{use of undeclared identifier 'NotNS'}}
12 
13 using NS::NotNS::x UIE; // expected-error{{no member named 'NotNS' in namespace 'test_basic::NS'}}
14 } // namespace test_basic
15 
16 namespace test_redecl {
17 namespace NS {}
18 
19 using NS::x UIE;
20 using NS::x UIE;
21 
22 namespace NS1 {}
23 namespace NS2 {}
24 namespace NS3 {
25 int A();     // expected-note{{target of using declaration}}
26 struct B {}; // expected-note{{target of using declaration}}
27 int C();     // expected-note{{conflicting declaration}}
28 struct D {}; // expected-note{{conflicting declaration}}
29 } // namespace NS3
30 
31 using NS1::A UIE;
32 using NS2::A UIE; // expected-note{{using declaration annotated with 'using_if_exists' here}} expected-note{{conflicting declaration}}
33 using NS3::A UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}}
34 int i = A();      // expected-error{{reference to unresolved using declaration}}
35 
36 using NS1::B UIE;
37 using NS2::B UIE; // expected-note{{conflicting declaration}} expected-note{{using declaration annotated with 'using_if_exists' here}}
38 using NS3::B UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}}
39 B myB;            // expected-error{{reference to unresolved using declaration}}
40 
41 using NS3::C UIE;
42 using NS2::C UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
43 int j = C();
44 
45 using NS3::D UIE;
46 using NS2::D UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
47 D myD;
48 } // namespace test_redecl
49 
50 namespace test_dependent {
51 template <class B>
52 struct S : B {
53   using B::mf UIE;          // expected-note 3 {{using declaration annotated with 'using_if_exists' here}}
54   using typename B::mt UIE; // expected-note{{using declaration annotated with 'using_if_exists' here}}
55 };
56 
57 struct BaseEmpty {
58 };
59 struct BaseNonEmpty {
60   void mf();
61   typedef int mt;
62 };
63 
64 template <class Base>
65 struct UseCtor : Base {
66   using Base::Base UIE; // expected-error{{'using_if_exists' attribute cannot be applied to an inheriting constructor}}
67 };
68 struct BaseCtor {};
69 
70 void f() {
71   S<BaseEmpty> empty;
72   S<BaseNonEmpty> nonempty;
73   empty.mf(); // expected-error {{reference to unresolved using declaration}}
74   nonempty.mf();
75   (&empty)->mf(); // expected-error {{reference to unresolved using declaration}}
76   (&nonempty)->mf();
77 
78   S<BaseEmpty>::mt y; // expected-error {{reference to unresolved using declaration}}
79   S<BaseNonEmpty>::mt z;
80 
81   S<BaseEmpty>::mf(); // expected-error {{reference to unresolved using declaration}}
82 
83   UseCtor<BaseCtor> usector;
84 }
85 
86 template <class B>
87 struct Implicit : B {
88   using B::mf UIE;          // expected-note {{using declaration annotated with 'using_if_exists' here}}
89   using typename B::mt UIE; // expected-note 2 {{using declaration annotated with 'using_if_exists' here}}
90 
91   void use() {
92     mf(); // expected-error {{reference to unresolved using declaration}}
93     mt x; // expected-error {{reference to unresolved using declaration}}
94   }
95 
96   mt alsoUse(); // expected-error {{reference to unresolved using declaration}}
97 };
98 
99 void testImplicit() {
100   Implicit<BaseNonEmpty> nonempty;
101   Implicit<BaseEmpty> empty; // expected-note {{in instantiation}}
102   nonempty.use();
103   empty.use(); // expected-note {{in instantiation}}
104 }
105 
106 template <class>
107 struct NonDep : BaseEmpty {
108   using BaseEmpty::x UIE; // expected-note{{using declaration annotated with 'using_if_exists' here}}
109   x y();                  // expected-error{{reference to unresolved using declaration}}
110 };
111 } // namespace test_dependent
112 
113 namespace test_using_pack {
114 template <class... Ts>
115 struct S : Ts... {
116   using typename Ts::x... UIE; // expected-error 2 {{target of using declaration conflicts with declaration already in scope}} expected-note{{conflicting declaration}} expected-note{{target of using declaration}}
117 };
118 
119 struct E1 {};
120 struct E2 {};
121 S<E1, E2> a;
122 
123 struct F1 {
124   typedef int x; // expected-note 2 {{conflicting declaration}}
125 };
126 struct F2 {
127   typedef int x; // expected-note 2 {{target of using declaration}}
128 };
129 S<F1, F2> b;
130 
131 S<E1, F2> c; // expected-note{{in instantiation of template class}}
132 S<F1, E2> d; // expected-note{{in instantiation of template class}}
133 
134 template <class... Ts>
135 struct S2 : Ts... {
136   using typename Ts::x... UIE; // expected-error 2 {{target of using declaration conflicts with declaration already in scope}} expected-note 3 {{using declaration annotated with 'using_if_exists' here}} expected-note{{conflicting declaration}} expected-note{{target of using declaration}}
137 
138   x mem(); // expected-error 3 {{reference to unresolved using declaration}}
139 };
140 
141 S2<E1, E2> e; // expected-note{{in instantiation of template class}}
142 S2<F1, F2> f;
143 S2<E1, F2> g; // expected-note{{in instantiation of template class}}
144 S2<F1, E2> h; // expected-note{{in instantiation of template class}}
145 
146 template <class... Ts>
147 struct S3 : protected Ts... {
148   using Ts::m... UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
149 };
150 struct B1 {
151   enum { m }; // expected-note{{conflicting declaration}}
152 };
153 struct B2 {};
154 
155 S3<B1, B2> i; // expected-note{{in instantiation of template}}
156 S<B2, B1> j;
157 
158 } // namespace test_using_pack
159 
160 namespace test_nested {
161 namespace NS {}
162 
163 using NS::x UIE; // expected-note {{using declaration annotated with 'using_if_exists' here}}
164 
165 namespace NS2 {
166 using ::test_nested::x UIE;
167 }
168 
169 NS2::x y; // expected-error {{reference to unresolved using declaration}}
170 } // namespace test_nested
171 
172 namespace test_scope {
173 int x; // expected-note{{conflicting declaration}}
174 void f() {
175   int x; // expected-note{{conflicting declaration}}
176   {
177     using ::x UIE; // expected-note {{using declaration annotated with 'using_if_exists' here}}
178     (void)x;       // expected-error {{reference to unresolved using declaration}}
179   }
180 
181   {
182     using test_scope::x;
183     using ::x UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
184     (void)x;
185   }
186 
187   (void)x;
188 
189   using ::x UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
190   (void)x;
191 }
192 } // namespace test_scope
193 
194 namespace test_appertains_to {
195 namespace NS {
196 typedef int x;
197 }
198 
199 // FIXME: This diagnostics is wrong.
200 using alias UIE = NS::x; // expected-error {{'using_if_exists' attribute only applies to named declarations, types, and value declarations}}
201 
202 template <class>
203 using template_alias UIE = NS::x; // expected-error {{'using_if_exists' attribute only applies to named declarations, types, and value declarations}}
204 
205 void f() UIE; // expected-error {{'using_if_exists' attribute only applies to named declarations, types, and value declarations}}
206 
207 using namespace NS UIE; // expected-error {{'using_if_exists' attribute only applies to named declarations, types, and value declarations}}
208 } // namespace test_appertains_to
209 
210 typedef int *fake_FILE;
211 int fake_printf();
212 
213 namespace std {
214 using ::fake_FILE UIE;
215 using ::fake_printf UIE;
216 using ::fake_fopen UIE;  // expected-note {{using declaration annotated with 'using_if_exists' here}}
217 using ::fake_size_t UIE; // expected-note {{using declaration annotated with 'using_if_exists' here}}
218 } // namespace std
219 
220 int main() {
221   std::fake_FILE file;
222   file = std::fake_fopen(); // expected-error {{reference to unresolved using declaration}} expected-error{{incompatible integer to pointer}}
223   std::fake_size_t size;    // expected-error {{reference to unresolved using declaration}}
224   size = fake_printf();
225   size = std::fake_printf();
226 }
227