Mercurial > hg > CbC > CbC_llvm

comparison clang/test/SemaTemplate/dependent-names.cpp @ 150:1d019706d866

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children 2e18cbf3894f
comparison
equal deleted inserted replaced
147:c2174574ed3a 150:1d019706d866
1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2
3 typedef double A;
4 template<typename T> class B {
5 typedef int A;
6 };
7
8 template<typename T> struct X : B<T> {
9 static A a;
10 };
11
12 int a0[sizeof(X<int>::a) == sizeof(double) ? 1 : -1];
13
14 // PR4365.
15 template<class T> class Q;
16 template<class T> class R : Q<T> {T current;};
17
18
19 namespace test0 {
20 template <class T> class Base {
21 public:
22 void instance_foo();
23 static void static_foo();
24 class Inner {
25 public:
26 void instance_foo();
27 static void static_foo();
28 };
29 };
30
31 template <class T> class Derived1 : Base<T> {
32 public:
33 void test0() {
34 Base<T>::static_foo();
35 Base<T>::instance_foo();
36 }
37
38 void test1() {
39 Base<T>::Inner::static_foo();
40 Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
41 }
42
43 static void test2() {
44 Base<T>::static_foo();
45 Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
46 }
47
48 static void test3() {
49 Base<T>::Inner::static_foo();
50 Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
51 }
52 };
53
54 template <class T> class Derived2 : Base<T>::Inner {
55 public:
56 void test0() {
57 Base<T>::static_foo();
58 Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
59 }
60
61 void test1() {
62 Base<T>::Inner::static_foo();
63 Base<T>::Inner::instance_foo();
64 }
65
66 static void test2() {
67 Base<T>::static_foo();
68 Base<T>::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
69 }
70
71 static void test3() {
72 Base<T>::Inner::static_foo();
73 Base<T>::Inner::instance_foo(); // expected-error {{call to non-static member function without an object argument}}
74 }
75 };
76
77 void test0() {
78 Derived1<int> d1;
79 d1.test0();
80 d1.test1(); // expected-note {{in instantiation of member function}}
81 d1.test2(); // expected-note {{in instantiation of member function}}
82 d1.test3(); // expected-note {{in instantiation of member function}}
83
84 Derived2<int> d2;
85 d2.test0(); // expected-note {{in instantiation of member function}}
86 d2.test1();
87 d2.test2(); // expected-note {{in instantiation of member function}}
88 d2.test3(); // expected-note {{in instantiation of member function}}
89 }
90 }
91
92 namespace test1 {
93 template <class T> struct Base {
94 void foo(T); // expected-note {{must qualify identifier to find this declaration in dependent base class}}
95 };
96
97 template <class T> struct Derived : Base<T> {
98 void doFoo(T v) {
99 foo(v); // expected-error {{use of undeclared identifier}}
100 }
101 };
102
103 template struct Derived<int>; // expected-note {{requested here}}
104 }
105
106 namespace PR8966 {
107 template <class T>
108 class MyClassCore
109 {
110 };
111
112 template <class T>
113 class MyClass : public MyClassCore<T>
114 {
115 public:
116 enum {
117 N
118 };
119
120 // static member declaration
121 static const char* array [N];
122
123 void f() {
124 MyClass<T>::InBase = 17;
125 }
126 };
127
128 // static member definition
129 template <class T>
130 const char* MyClass<T>::array [MyClass<T>::N] = { "A", "B", "C" };
131 }
132
133 namespace std {
134 inline namespace v1 {
135 template<typename T> struct basic_ostream;
136 }
137 namespace inner {
138 template<typename T> struct vector {};
139 }
140 using inner::vector;
141 template<typename T, typename U> struct pair {};
142 typedef basic_ostream<char> ostream;
143 extern ostream cout;
144 std::ostream &operator<<(std::ostream &out, const char *);
145 }
146
147 namespace PR10053 {
148 template<typename T> struct A {
149 T t;
150 A() {
151 f(t); // expected-error {{call to function 'f' that is neither visible in the template definition nor found by argument-dependent lookup}}
152 }
153 };
154
155 void f(int&); // expected-note {{'f' should be declared prior to the call site}}
156
157 A<int> a; // expected-note {{in instantiation of member function}}
158
159
160 namespace N {
161 namespace M {
162 template<typename T> int g(T t) {
163 f(t); // expected-error {{call to function 'f' that is neither visible in the template definition nor found by argument-dependent lookup}}
164 };
165 }
166
167 void f(char&); // expected-note {{'f' should be declared prior to the call site}}
168 }
169
170 void f(char&);
171
172 int k = N::M::g<char>(0);; // expected-note {{in instantiation of function}}
173
174
175 namespace O {
176 void f(char&); // expected-note {{candidate function not viable}}
177
178 template<typename T> struct C {
179 static const int n = f(T()); // expected-error {{no matching function}}
180 };
181 }
182
183 int f(double); // no note, shadowed by O::f
184 O::C<double> c; // expected-note {{requested here}}
185
186
187 // Example from www/compatibility.html
188 namespace my_file {
189 template <typename T> T Squared(T x) {
190 return Multiply(x, x); // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
191 }
192
193 int Multiply(int x, int y) { // expected-note {{should be declared prior to the call site}}
194 return x * y;
195 }
196
197 int main() {
198 Squared(5); // expected-note {{here}}
199 }
200 }
201
202 // Example from www/compatibility.html
203 namespace my_file2 {
204 template<typename T>
205 void Dump(const T& value) {
206 std::cout << value << "\n"; // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
207 }
208
209 namespace ns {
210 struct Data {};
211 }
212
213 std::ostream& operator<<(std::ostream& out, ns::Data data) { // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2::ns'}}
214 return out << "Some data";
215 }
216
217 void Use() {
218 Dump(ns::Data()); // expected-note {{here}}
219 }
220 }
221
222 namespace my_file2_a {
223 template<typename T>
224 void Dump(const T &value) {
225 print(std::cout, value); // expected-error 4{{neither visible in the template definition nor found by argument-dependent lookup}}
226 }
227
228 namespace ns {
229 struct Data {};
230 }
231 namespace ns2 {
232 struct Data {};
233 }
234
235 std::ostream &print(std::ostream &out, int); // expected-note-re {{should be declared prior to the call site{{$}}}}
236 std::ostream &print(std::ostream &out, ns::Data); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns'}}
237 std::ostream &print(std::ostream &out, std::vector<ns2::Data>); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::my_file2_a::ns2'}}
238 std::ostream &print(std::ostream &out, std::pair<ns::Data, ns2::Data>); // expected-note {{should be declared prior to the call site or in an associated namespace of one of its arguments}}
239
240 void Use() {
241 Dump(0); // expected-note {{requested here}}
242 Dump(ns::Data()); // expected-note {{requested here}}
243 Dump(std::vector<ns2::Data>()); // expected-note {{requested here}}
244 Dump(std::pair<ns::Data, ns2::Data>()); // expected-note {{requested here}}
245 }
246 }
247
248 namespace unary {
249 template<typename T>
250 T Negate(const T& value) {
251 return !value; // expected-error {{call to function 'operator!' that is neither visible in the template definition nor found by argument-dependent lookup}}
252 }
253
254 namespace ns {
255 struct Data {};
256 }
257
258 ns::Data operator!(ns::Data); // expected-note {{should be declared prior to the call site or in namespace 'PR10053::unary::ns'}}
259
260 void Use() {
261 Negate(ns::Data()); // expected-note {{requested here}}
262 }
263 }
264 }
265
266 namespace PR10187 {
267 namespace A1 {
268 template<typename T>
269 struct S {
270 void f() {
271 for (auto &a : e)
272 __range(a); // expected-error {{undeclared identifier '__range'}}
273 }
274 int e[10];
275 };
276 }
277
278 namespace A2 {
279 template<typename T>
280 struct S {
281 void f() {
282 for (auto &a : e)
283 __range(a); // expected-error {{undeclared identifier '__range'}}
284 }
285 T e[10];
286 };
287 void g() {
288 S<int>().f(); // expected-note {{here}}
289 }
290 struct X {};
291 void __range(X);
292 void h() {
293 S<X>().f();
294 }
295 }
296
297 namespace B {
298 template<typename T> void g(); // expected-note {{not viable}}
299 template<typename T> void f() {
300 g<int>(T()); // expected-error {{no matching function}}
301 }
302
303 namespace {
304 struct S {};
305 }
306 void g(S);
307
308 template void f<S>(); // expected-note {{here}}
309 }
310 }
311
312 namespace rdar11242625 {
313
314 template <typename T>
315 struct Main {
316 struct default_names {
317 typedef int id;
318 };
319
320 template <typename T2 = typename default_names::id>
321 struct TS {
322 T2 q;
323 };
324 };
325
326 struct Sub : public Main<int> {
327 TS<> ff;
328 };
329
330 int arr[sizeof(Sub)];
331
332 }
333
334 namespace PR11421 {
335 template < unsigned > struct X {
336 static const unsigned dimension = 3;
337 template<unsigned dim=dimension>
338 struct Y: Y<dim> { }; // expected-error{{circular inheritance between 'Y<dim>' and 'Y<dim>'}}
339 };
340 typedef X<3> X3;
341 X3::Y<>::iterator it; // expected-error {{no type named 'iterator' in 'PR11421::X<3>::Y<3>'}}
342 }
343
344 namespace rdar12629723 {
345 template<class T>
346 struct X {
347 struct C : public C { }; // expected-error{{circular inheritance between 'rdar12629723::X::C' and 'rdar12629723::X::C'}}
348
349 struct B;
350
351 struct A : public B { // expected-note{{'rdar12629723::X::A' declared here}}
352 virtual void foo() { }
353 };
354
355 struct D : T::foo { };
356 struct E : D { };
357 };
358
359 template<class T>
360 struct X<T>::B : public A { // expected-error{{circular inheritance between 'rdar12629723::X::A' and 'rdar12629723::X::B'}}
361 virtual void foo() { }
362 };
363 }
364
365 namespace test_reserved_identifiers {
366 template<typename A, typename B> void tempf(A a, B b) {
367 a + b; // expected-error{{call to function 'operator+' that is neither visible in the template definition nor found by argument-dependent lookup}}
368 }
369 namespace __gnu_cxx { struct X {}; }
370 namespace ns { struct Y {}; }
371 void operator+(__gnu_cxx::X, ns::Y); // expected-note{{or in namespace 'test_reserved_identifiers::ns'}}
372 void test() {
373 __gnu_cxx::X x;
374 ns::Y y;
375 tempf(x, y); // expected-note{{in instantiation of}}
376 }
377 }
378
379 // This test must live in the global namespace.
380 struct PR14695_X {};
381 // FIXME: This note is bogus; it is the using directive which would need to move
382 // to prior to the call site to fix the problem.
383 namespace PR14695_A { void PR14695_f(PR14695_X); } // expected-note {{'PR14695_f' should be declared prior to the call site or in the global namespace}}
384 template<typename T> void PR14695_g(T t) { PR14695_f(t); } // expected-error {{call to function 'PR14695_f' that is neither visible in the template definition nor found by argument-dependent lookup}}
385 using namespace PR14695_A;
386 template void PR14695_g(PR14695_X); // expected-note{{requested here}}
387
388 namespace OperatorNew {
389 template<typename T> void f(T t) {
390 operator new(100, t); // expected-error{{call to function 'operator new' that is neither visible in the template definition nor found by argument-dependent lookup}}
391 // FIXME: This should give the same error.
392 new (t) int;
393 }
394 struct X {};
395 };
396 using size_t = decltype(sizeof(0));
397 void *operator new(size_t, OperatorNew::X); // expected-note-re {{should be declared prior to the call site{{$}}}}
398 template void OperatorNew::f(OperatorNew::X); // expected-note {{instantiation of}}
399
400 namespace PR19936 {
401 template<typename T> decltype(*T()) f() {} // expected-note {{previous}}
402 template<typename T> decltype(T() * T()) g() {} // expected-note {{previous}}
403
404 // Create some overloaded operators so we build an overload operator call
405 // instead of a builtin operator call for the dependent expression.
406 enum E {};
407 int operator*(E);
408 int operator*(E, E);
409
410 // Check that they still profile the same.
411 template<typename T> decltype(*T()) f() {} // expected-error {{redefinition}}
412 template<typename T> decltype(T() * T()) g() {} // expected-error {{redefinition}}
413 }
414
415 template <typename> struct CT2 {
416 template <class U> struct X;
417 };
418 template <typename T> int CT2<int>::X<>; // expected-error {{template parameter list matching the non-templated nested type 'CT2<int>' should be empty}}
419
420 namespace DependentTemplateIdWithNoArgs {
421 template<typename T> void f() { T::template f(); }
422 struct X {
423 template<int = 0> static void f();
424 };
425 void g() { f<X>(); }
426 }
427
428 namespace DependentUnresolvedUsingTemplate {
429 template<typename T>
430 struct X : T {
431 using T::foo;
432 void f() { this->template foo(); } // expected-error {{does not refer to a template}}
433 void g() { this->template foo<>(); } // expected-error {{does not refer to a template}}
434 void h() { this->template foo<int>(); } // expected-error {{does not refer to a template}}
435 };
436 struct A { template<typename = int> int foo(); };
437 struct B { int foo(); }; // expected-note 3{{non-template here}}
438 void test(X<A> xa, X<B> xb) {
439 xa.f();
440 xa.g();
441 xa.h();
442 xb.f(); // expected-note {{instantiation of}}
443 xb.g(); // expected-note {{instantiation of}}
444 xb.h(); // expected-note {{instantiation of}}
445 }
446 }
447
448 namespace PR37680 {
449 template <class a> struct b : a {
450 using a::add;
451 template<int> int add() { return this->template add(0); }
452 };
453 struct a {
454 template<typename T = void> int add(...);
455 void add(int);
456 };
457 int f(b<a> ba) { return ba.add<0>(); }
458 }