Clang Project

clang_source_code/test/SemaTemplate/dependent-names.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 
2
3typedef double A;
4template<typename T> class B {
5  typedef int A;
6};
7
8template<typename T> struct X : B<T> {
9  static A a;
10};
11
12int a0[sizeof(X<int>::a) == sizeof(double) ? 1 : -1];
13
14// PR4365.
15template<class T> class Q;
16template<class T> class R : Q<T> {T current;};
17
18
19namespace 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
92namespace 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
106namespace 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
133namespace 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
147namespace 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
266namespace 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    void g() {
277      S<int>().f(); // expected-note {{here}}
278    }
279  }
280
281  namespace A2 {
282    template<typename T>
283    struct S {
284      void f() {
285        for (auto &a : e)
286          __range(a); // expected-error {{undeclared identifier '__range'}}
287      }
288      T e[10];
289    };
290    void g() {
291      S<int>().f(); // expected-note {{here}}
292    }
293    struct X {};
294    void __range(X);
295    void h() {
296      S<X>().f();
297    }
298  }
299
300  namespace B {
301    template<typename T> void g(); // expected-note {{not viable}}
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
315namespace rdar11242625 {
316
317template <typename T>
318struct 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
329struct Sub : public Main<int> {
330  TS<> ff;
331};
332
333int arr[sizeof(Sub)];
334
335}
336
337namespace PR11421 {
338template < 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};
343typedef X<3> X3;
344X3::Y<>::iterator it; // expected-error {{no type named 'iterator' in 'PR11421::X<3>::Y<3>'}}
345}
346
347namespace 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}}
355      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'}}
364    virtual void foo() { }
365  };
366}
367
368namespace test_reserved_identifiers {
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'}}
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.
383struct 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.
386namespace PR14695_A { void PR14695_f(PR14695_X); } // expected-note {{'PR14695_f' should be declared prior to the call site or in the global namespace}}
387template<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}}
388using namespace PR14695_A;
389template void PR14695_g(PR14695_X); // expected-note{{requested here}}
390
391namespace OperatorNew {
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};
399using size_t = decltype(sizeof(0));
400void *operator new(size_t, OperatorNew::X); // expected-note-re {{should be declared prior to the call site{{$}}}}
401template void OperatorNew::f(OperatorNew::X); // expected-note {{instantiation of}}
402
403namespace PR19936 {
404  template<typename T> decltype(*T()) f() {} // expected-note {{previous}}
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.
414  template<typename T> decltype(*T()) f() {} // expected-error {{redefinition}}
415  template<typename T> decltype(T() * T()) g() {} // expected-error {{redefinition}}
416}
417
418template <typename> struct CT2 {
419  template <class U> struct X;
420};
421template <typename T> int CT2<int>::X<>; // expected-error {{template parameter list matching the non-templated nested type 'CT2<int>' should be empty}}
422
423namespace DependentTemplateIdWithNoArgs {
424  template<typename T> void f() { T::template f(); }
425  struct X {
426    template<int = 0> static void f();
427  };
428  void g() { f<X>(); }
429}
430
431namespace DependentUnresolvedUsingTemplate {
432  template<typename T>
433  struct X : T {
434    using T::foo;
435    void f() { this->template foo(); } // expected-error {{does not refer to a template}}
436    void g() { this->template foo<>(); } // expected-error {{does not refer to a template}}
437    void h() { this->template foo<int>(); } // expected-error {{does not refer to a template}}
438  };
439  struct A { template<typename = int> int foo(); };
440  struct B { int foo(); }; // expected-note 3{{non-template here}}
441  void test(X<A> xa, X<B> xb) {
442    xa.f();
443    xa.g();
444    xa.h();
445    xb.f(); // expected-note {{instantiation of}}
446    xb.g(); // expected-note {{instantiation of}}
447    xb.h(); // expected-note {{instantiation of}}
448  }
449}
450
451namespace PR37680 {
452  template <class a> struct b : a {
453    using a::add;
454    template<int> int add() { return this->template add(0); }
455  };
456  struct a {
457    template<typename T = void> int add(...);
458    void add(int);
459  };
460  int f(b<a> ba) { return ba.add<0>(); }
461}
462
CodeThinker, Enjoy your reading code