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:
test0()33 void test0() {
34 Base<T>::static_foo();
35 Base<T>::instance_foo();
36 }
37
test1()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
test2()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
test3()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:
test0()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
test1()61 void test1() {
62 Base<T>::Inner::static_foo();
63 Base<T>::Inner::instance_foo();
64 }
65
test2()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
test3()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
test0()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> {
doFootest1::Derived98 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
f()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;
APR10053::A150 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 {
g(T t)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 {
Squared(T x)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
Multiply(int x,int y)193 int Multiply(int x, int y) { // expected-note {{should be declared prior to the call site}}
194 return x * y;
195 }
196
main()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>
Dump(const T & value)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
operator <<(std::ostream & out,ns::Data data)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
Use()217 void Use() {
218 Dump(ns::Data()); // expected-note {{here}}
219 }
220 }
221
222 namespace my_file2_a {
223 template<typename T>
Dump(const T & value)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
Use()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>
Negate(const T & value)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
Use()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 {
fPR10187::A1::S270 void f() {
271 for (auto &a : e)
272 __range(a); // expected-error {{undeclared identifier '__range'}}
273 }
274 int e[10];
275 };
g()276 void g() {
277 S<int>().f(); // expected-note {{here}}
278 }
279 }
280
281 namespace A2 {
282 template<typename T>
283 struct S {
fPR10187::A2::S284 void f() {
285 for (auto &a : e)
286 __range(a); // expected-error {{undeclared identifier '__range'}}
287 }
288 T e[10];
289 };
g()290 void g() {
291 S<int>().f(); // expected-note {{here}}
292 }
293 struct X {};
294 void __range(X);
h()295 void h() {
296 S<X>().f();
297 }
298 }
299
300 namespace B {
301 template<typename T> void g(); // expected-note {{not viable}}
f()302 template<typename T> void f() {
303 g<int>(T()); // expected-error {{no matching function}}
304 }
305
306 namespace {
307 struct S {};
308 }
309 void g(S);
310
311 template void f<S>(); // expected-note {{here}}
312 }
313 }
314
315 namespace rdar11242625 {
316
317 template <typename T>
318 struct Main {
319 struct default_names {
320 typedef int id;
321 };
322
323 template <typename T2 = typename default_names::id>
324 struct TS {
325 T2 q;
326 };
327 };
328
329 struct Sub : public Main<int> {
330 TS<> ff;
331 };
332
333 int arr[sizeof(Sub)];
334
335 }
336
337 namespace PR11421 {
338 template < unsigned > struct X {
339 static const unsigned dimension = 3;
340 template<unsigned dim=dimension>
341 struct Y: Y<dim> { }; // expected-error{{circular inheritance between 'Y<dim>' and 'Y<dim>'}}
342 };
343 typedef X<3> X3;
344 X3::Y<>::iterator it; // expected-error {{no type named 'iterator' in 'PR11421::X<3>::Y<3>'}}
345 }
346
347 namespace rdar12629723 {
348 template<class T>
349 struct X {
350 struct C : public C { }; // expected-error{{circular inheritance between 'rdar12629723::X::C' and 'rdar12629723::X::C'}}
351
352 struct B;
353
354 struct A : public B { // expected-note{{'rdar12629723::X::A' declared here}}
foordar12629723::X::A355 virtual void foo() { }
356 };
357
358 struct D : T::foo { };
359 struct E : D { };
360 };
361
362 template<class T>
363 struct X<T>::B : public A { // expected-error{{circular inheritance between 'rdar12629723::X::A' and 'rdar12629723::X::B'}}
foordar12629723::X::B364 virtual void foo() { }
365 };
366 }
367
368 namespace test_reserved_identifiers {
tempf(A a,B b)369 template<typename A, typename B> void tempf(A a, B b) {
370 a + b; // expected-error{{call to function 'operator+' that is neither visible in the template definition nor found by argument-dependent lookup}}
371 }
372 namespace __gnu_cxx { struct X {}; }
373 namespace ns { struct Y {}; }
374 void operator+(__gnu_cxx::X, ns::Y); // expected-note{{or in namespace 'test_reserved_identifiers::ns'}}
test()375 void test() {
376 __gnu_cxx::X x;
377 ns::Y y;
378 tempf(x, y); // expected-note{{in instantiation of}}
379 }
380 }
381
382 // This test must live in the global namespace.
383 struct PR14695_X {};
384 // FIXME: This note is bogus; it is the using directive which would need to move
385 // to prior to the call site to fix the problem.
386 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}}
PR14695_g(T t)387 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}}
388 using namespace PR14695_A;
389 template void PR14695_g(PR14695_X); // expected-note{{requested here}}
390
391 namespace OperatorNew {
f(T t)392 template<typename T> void f(T t) {
393 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}}
394 // FIXME: This should give the same error.
395 new (t) int;
396 }
397 struct X {};
398 };
399 using size_t = decltype(sizeof(0));
400 void *operator new(size_t, OperatorNew::X); // expected-note-re {{should be declared prior to the call site{{$}}}}
401 template void OperatorNew::f(OperatorNew::X); // expected-note {{instantiation of}}
402
403 namespace PR19936 {
T()404 template<typename T> decltype(*T()) f() {} // expected-note {{previous}}
T()405 template<typename T> decltype(T() * T()) g() {} // expected-note {{previous}}
406
407 // Create some overloaded operators so we build an overload operator call
408 // instead of a builtin operator call for the dependent expression.
409 enum E {};
410 int operator*(E);
411 int operator*(E, E);
412
413 // Check that they still profile the same.
T()414 template<typename T> decltype(*T()) f() {} // expected-error {{redefinition}}
T()415 template<typename T> decltype(T() * T()) g() {} // expected-error {{redefinition}}
416 }
417
418 template <typename> struct CT2 {
419 template <class U> struct X;
420 };
421 template <typename T> int CT2<int>::X<>; // expected-error {{template parameter list matching the non-templated nested type 'CT2<int>' should be empty}}
422