• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  // RUN: %clang_cc1 -verify -std=c++11 %s
2  // RUN: %clang_cc1 -verify -std=c++11 -fdelayed-template-parsing %s
3  
4  template<typename T>
f0()5  void f0() {
6    struct X;
7    typedef struct Y {
8      T (X::* f1())(int) { return 0; }
9    } Y2;
10  
11    Y2 y = Y();
12  }
13  
14  template void f0<int>();
15  
16  // PR5764
17  namespace PR5764 {
18    struct X {
19      template <typename T>
BarPR5764::X20      void Bar() {
21        typedef T ValueType;
22        struct Y {
23          Y() { V = ValueType(); }
24  
25          ValueType V;
26        };
27  
28        Y y;
29      }
30    };
31  
test(X x)32    void test(X x) {
33      x.Bar<int>();
34    }
35  }
36  
37  // Instantiation of local classes with virtual functions.
38  namespace local_class_with_virtual_functions {
39    template <typename T> struct X { };
40    template <typename T> struct Y { };
41  
42    template <typename T>
f()43    void f() {
44      struct Z : public X<Y<T>*> {
45        virtual void g(Y<T>* y) { }
46        void g2(int x) {(void)x;}
47      };
48      Z z;
49      (void)z;
50    }
51  
52    struct S { };
test()53    void test() { f<S>(); }
54  }
55  
56  namespace PR8801 {
57    template<typename T>
foo()58    void foo() {
59      class X;
60      typedef int (X::*pmf_type)();
61      class X : public T { };
62  
63      pmf_type pmf = &T::foo;
64    }
65  
66    struct Y { int foo(); };
67  
68    template void foo<Y>();
69  }
70  
71  namespace TemplatePacksAndLambdas {
72    template <typename ...T> int g(T...);
73    struct S {
fTemplatePacksAndLambdas::S74      template <typename ...T> static void f(int f = g([]{ static T t; return ++t; }()...)) {}
75    };
h()76    void h() { S::f<int, int, int>(); }
77  }
78  
79  namespace PR9685 {
forEach(Thing t)80    template <class Thing> void forEach(Thing t) { t.func(); }
81  
doIt()82    template <typename T> void doIt() {
83      struct Functor {
84        void func() { (void)i; }
85        int i;
86      };
87  
88      forEach(Functor());
89    }
90  
call()91    void call() {
92      doIt<int>();
93    }
94  }
95  
96  namespace PR12702 {
97    struct S {
applyPR12702::S98      template <typename F> bool apply(F f) { return f(); }
99    };
100  
101    template <typename> struct T {
fooPR12702::T102      void foo() {
103        struct F {
104          int x;
105  
106          bool operator()() { return x == 0; }
107        };
108  
109        S().apply(F());
110      }
111    };
112  
call()113    void call() { T<int>().foo(); }
114  }
115  
116  namespace PR17139 {
foo(const T & t)117    template <class T> void foo(const T &t) { t.foo(); }
118  
bar(F * f)119    template <class F> void bar(F *f) {
120      struct B {
121        F *fn;
122        void foo() const { fn(); }
123      } b = { f };
124      foo(b);
125    }
126  
go()127    void go() {}
128  
test()129    void test() { bar(go); }
130  }
131  
132  namespace PR17740 {
133  class C {
134  public:
135    template <typename T> static void foo(T function);
136    template <typename T> static void bar(T function);
137    template <typename T> static void func(T function);
138  };
139  
foo(T function)140  template <typename T> void C::foo(T function) { function(); }
141  
bar(T function)142  template <typename T> void C::bar(T function) {
143    foo([&function]() { function(); });
144  }
145  
func(T function)146  template <typename T> void C::func(T function) {
147    struct Struct {
148      T mFunction;
149  
150      Struct(T function) : mFunction(function) {};
151  
152      void operator()() {
153        mFunction();
154      };
155    };
156  
157    bar(Struct(function));
158  }
159  
call()160  void call() {
161    C::func([]() {});
162  }
163  }
164  
165  namespace PR14373 {
166    struct function {
functionPR14373::function167      template <typename _Functor> function(_Functor __f) { __f(); }
168    };
exec_func(Func f)169    template <typename Func> function exec_func(Func f) {
170      struct functor {
171        functor(Func f) : func(f) {}
172        void operator()() const { func(); }
173        Func func;
174      };
175      return functor(f);
176    }
177    struct Type {
operator ()PR14373::Type178      void operator()() const {}
179    };
call()180    int call() {
181      exec_func(Type());
182      return 0;
183    }
184  }
185  
186  namespace PR18907 {
187  template <typename>
188  class C : public C<int> {}; // expected-error{{within its own definition}}
189  
190  template <typename X>
F()191  void F() {
192    struct A : C<X> {};
193  }
194  
195  struct B {
fPR18907::B196    void f() { F<int>(); }
197  };
198  }
199  
200  namespace PR23194 {
201    struct X {
operator ()PR23194::X202      int operator()() const { return 0; }
203    };
204    struct Y {
YPR23194::Y205      Y(int) {}
206    };
make_seed_pair()207    template <bool = true> int make_seed_pair() noexcept {
208      struct state_t {
209        X x;
210        Y y{x()};
211      };
212      return 0;
213    }
func()214    int func() {
215      return make_seed_pair();
216    }
217  }
218  
219  namespace PR18653 {
220    // Forward declarations
221  
f1()222    template<typename T> void f1() {
223      void g1(struct x1);
224      struct x1 {};
225    }
226    template void f1<int>();
227  
f1a()228    template<typename T> void f1a() {
229      void g1(union x1);
230      union x1 {};
231    }
232    template void f1a<int>();
233  
f2()234    template<typename T> void f2() {
235      void g2(enum x2);  // expected-error{{ISO C++ forbids forward references to 'enum' types}}
236      enum x2 { nothing };
237    }
238    template void f2<int>();
239  
f3()240    template<typename T> void f3() {
241      void g3(enum class x3);
242      enum class x3 { nothing };
243    }
244    template void f3<int>();
245  
246  
f4()247    template<typename T> void f4() {
248      void g4(struct x4 {} x);  // expected-error{{'x4' cannot be defined in a parameter type}}
249    }
250    template void f4<int>();
251  
f4a()252    template<typename T> void f4a() {
253      void g4(union x4 {} x);  // expected-error{{'x4' cannot be defined in a parameter type}}
254    }
255    template void f4a<int>();
256  
257  
258    template <class T> void f();
259    template <class T> struct S1 {
mPR18653::S1260      void m() {
261        f<class newclass>();
262        f<union newunion>();
263      }
264    };
265    template struct S1<int>;
266  
267    template <class T> struct S2 {
mPR18653::S2268      void m() {
269        f<enum new_enum>();  // expected-error{{ISO C++ forbids forward references to 'enum' types}}
270      }
271    };
272    template struct S2<int>;
273  
274    template <class T> struct S3 {
mPR18653::S3275      void m() {
276        f<enum class new_enum>();
277      }
278    };
279    template struct S3<int>;
280  
281    template <class T> struct S4 {
282      struct local {};
mPR18653::S4283      void m() {
284        f<local>();
285      }
286    };
287    template struct S4<int>;
288  
289    template <class T> struct S4a {
290      union local {};
mPR18653::S4a291      void m() {
292        f<local>();
293      }
294    };
295    template struct S4a<int>;
296  
297    template <class T> struct S5 {
298      enum local { nothing };
mPR18653::S5299      void m() {
300        f<local>();
301      }
302    };
303    template struct S5<int>;
304  
305    template <class T> struct S7 {
306      enum class local { nothing };
mPR18653::S7307      void m() {
308        f<local>();
309      }
310    };
311    template struct S7<int>;
312  
313  
314    template <class T> void fff(T *x);
315    template <class T> struct S01 {
316      struct local { };
mPR18653::S01317      void m() {
318        local x;
319        fff(&x);
320      }
321    };
322    template struct S01<int>;
323  
324    template <class T> struct S01a {
325      union local { };
mPR18653::S01a326      void m() {
327        local x;
328        fff(&x);
329      }
330    };
331    template struct S01a<int>;
332  
333    template <class T> struct S02 {
334      enum local { nothing };
mPR18653::S02335      void m() {
336        local x;
337        fff(&x);
338      }
339    };
340    template struct S02<int>;
341  
342    template <class T> struct S03 {
343      enum class local { nothing };
mPR18653::S03344      void m() {
345        local x;
346        fff(&x);
347      }
348    };
349    template struct S03<int>;
350  
351  
352    template <class T> struct S04 {
mPR18653::S04353      void m() {
354        struct { } x;
355        fff(&x);
356      }
357    };
358    template struct S04<int>;
359  
360    template <class T> struct S04a {
mPR18653::S04a361      void m() {
362        union { } x;
363        fff(&x);
364      }
365    };
366    template struct S04a<int>;
367  
368    template <class T> struct S05 {
mPR18653::S05369      void m() {
370        enum { nothing } x;
371        fff(&x);
372      }
373    };
374    template struct S05<int>;
375  
376    template <class T> struct S06 {
mPR18653::S06377      void m() {
378        class { virtual void mmm() {} } x;
379        fff(&x);
380      }
381    };
382    template struct S06<int>;
383  }
384  
385  namespace PR20625 {
386  template <typename T>
f()387  void f() {
388    struct N {
389      static constexpr int get() { return 42; }
390    };
391    constexpr int n = N::get();
392    static_assert(n == 42, "n == 42");
393  }
394  
g()395  void g() { f<void>(); }
396  }
397  
398  
399  namespace PR21332 {
f1()400    template<typename T> void f1() {
401      struct S {  // expected-note{{in instantiation of member class 'S' requested here}}
402        void g1(int n = T::error);  // expected-error{{type 'int' cannot be used prior to '::' because it has no members}}
403      };
404    }
405    template void f1<int>();  // expected-note{{in instantiation of function template specialization 'PR21332::f1<int>' requested here}}
406  
f2()407    template<typename T> void f2() {
408      struct S {  // expected-note{{in instantiation of member class 'S' requested here}}
409        void g2() noexcept(T::error);  // expected-error{{type 'int' cannot be used prior to '::' because it has no members}}
410      };
411    }
412    template void f2<int>();  // expected-note{{in instantiation of function template specialization 'PR21332::f2<int>' requested here}}
413  
f3()414    template<typename T> void f3() {
415      enum S {
416        val = T::error;  // expected-error{{expected '}' or ','}} expected-error{{type 'int' cannot be used prior to '::' because it has no members}}
417      };
418    }
419    template void f3<int>();  //expected-note{{in instantiation of function template specialization 'PR21332::f3<int>' requested here}}
420  
f4()421    template<typename T> void f4() {
422      enum class S {
423        val = T::error;  // expected-error{{expected '}' or ','}} expected-error{{type 'int' cannot be used prior to '::' because it has no members}}
424      };
425    }
426    template void f4<int>();  // expected-note{{in instantiation of function template specialization 'PR21332::f4<int>' requested here}}
427  
f5()428    template<typename T> void f5() {
429      class S {  // expected-note {{in instantiation of default member initializer 'PR21332::f5()::S::val' requested here}}
430        int val = T::error;  // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
431       };
432    }
433    template void f5<int>();  // expected-note {{in instantiation of function template specialization 'PR21332::f5<int>' requested here}}
434  
f6()435    template<typename T> void f6() {
436      class S {  // expected-note {{in instantiation of member function 'PR21332::f6()::S::get' requested here}}
437        void get() {
438          class S2 {  // expected-note {{in instantiation of member class 'S2' requested here}}
439            void g1(int n = T::error);  // expected-error {{type 'int' cannot be used prior to '::' because it has no members}}
440          };
441        }
442      };
443    }
444    template void f6<int>();  // expected-note{{in instantiation of function template specialization 'PR21332::f6<int>' requested here}}
445  
f7()446    template<typename T> void f7() {
447      struct S { void g() noexcept(undefined_val); };  // expected-error{{use of undeclared identifier 'undefined_val'}}
448    }
449    template void f7<int>();
450  }
451  
452  // rdar://23721638: Ensure that we correctly perform implicit
453  // conversions when instantiating the default arguments of local functions.
454  namespace rdar23721638 {
455    struct A {
456      A(const char *) = delete;  // expected-note 2 {{explicitly marked deleted here}}
457    };
458  
foo()459    template <typename T> void foo() {
460      struct Inner { // expected-note {{in instantiation}}
461        void operator()(T a = "") {} // expected-error {{conversion function from 'const char [1]' to 'rdar23721638::A' invokes a deleted function}}
462        // expected-note@-1 {{passing argument to parameter 'a' here}}
463        // expected-note@-2 {{candidate function not viable}}
464      };
465      Inner()(); // expected-error {{no matching function}}
466    }
467    template void foo<A>(); // expected-note 2 {{in instantiation}}
468  
bar()469    template <typename T> void bar() {
470      auto lambda = [](T a = "") {}; // expected-error {{conversion function from 'const char [1]' to 'rdar23721638::A' invokes a deleted function}}
471        // expected-note@-1 {{passing argument to parameter 'a' here}}
472        // expected-note@-2 {{candidate function not viable}}
473        // expected-note@-3 {{conversion candidate of type}}
474      lambda(); // expected-error {{no matching function}}
475    }
476    template void bar<A>(); // expected-note {{in instantiation}}
477  }
478