Clang Project

clang_source_code/test/SemaTemplate/instantiate-local-class.cpp
1// RUN: %clang_cc1 -verify -std=c++11 %s
2// RUN: %clang_cc1 -verify -std=c++11 -fdelayed-template-parsing %s
3
4template<typename T>
5void f0() {
6  struct X;
7  typedef struct Y {
8    T (X::* f1())(int) { return 0; }
9  } Y2;
10
11  Y2 y = Y();
12}
13
14template void f0<int>();
15
16// PR5764
17namespace PR5764 {
18  struct X {
19    template <typename T>
20    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
32  void test(X x) {
33    x.Bar<int>();
34  }
35}
36
37// Instantiation of local classes with virtual functions.
38namespace local_class_with_virtual_functions {
39  template <typename T> struct X { };
40  template <typename T> struct Y { };
41
42  template <typename T>
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 { };
53  void test() { f<S>(); }
54}
55
56namespace PR8801 {
57  template<typename T>
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
71namespace TemplatePacksAndLambdas {
72  template <typename ...T> int g(T...);
73  struct S {
74    template <typename ...T> static void f(int f = g([]{ static T t; return ++t; }()...)) {}
75  };
76  void h() { S::f<int, int, int>(); }
77}
78
79namespace PR9685 {
80  template <class Thing> void forEach(Thing t) { t.func(); }
81
82  template <typename T> void doIt() {
83    struct Functor {
84      void func() { (void)i; }
85      int i;
86    };
87
88    forEach(Functor());
89  }
90
91  void call() {
92    doIt<int>();
93  }
94}
95
96namespace PR12702 {
97  struct S {
98    template <typename F> bool apply(F f) { return f(); }
99  };
100
101  template <typename> struct T {
102    void foo() {
103      struct F {
104        int x;
105
106        bool operator()() { return x == 0; }
107      };
108
109      S().apply(F());
110    }
111  };
112
113  void call() { T<int>().foo(); }
114}
115
116namespace PR17139 {
117  template <class T> void foo(const T &t) { t.foo(); }
118
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
127  void go() {}
128
129  void test() { bar(go); }
130}
131
132namespace PR17740 {
133class C {
134public:
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
140template <typename T> void C::foo(T function) { function(); }
141
142template <typename T> void C::bar(T function) {
143  foo([&function]() { function(); });
144}
145
146template <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
160void call() {
161  C::func([]() {});
162}
163}
164
165namespace PR14373 {
166  struct function {
167    template <typename _Functor> function(_Functor __f) { __f(); }
168  };
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 {
178    void operator()() const {}
179  };
180  int call() {
181    exec_func(Type());
182    return 0;
183  }
184}
185
186namespace PR18907 {
187template <typename>
188class C : public C<int> {}; // expected-error{{within its own definition}}
189
190template <typename X>
191void F() {
192  struct A : C<X> {};
193}
194
195struct B {
196  void f() { F<int>(); }
197};
198}
199
200namespace PR23194 {
201  struct X {
202    int operator()() const { return 0; }
203  };
204  struct Y {
205    Y(int) {}
206  };
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  }
214  int func() {
215    return make_seed_pair();
216  }
217}
218
219namespace PR18653 {
220  // Forward declarations
221
222  template<typename T> void f1() {
223    void g1(struct x1);
224    struct x1 {};
225  }
226  template void f1<int>();
227
228  template<typename T> void f1a() {
229    void g1(union x1);
230    union x1 {};
231  }
232  template void f1a<int>();
233
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
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
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
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 {
260    void m() {
261      f<class newclass>();
262      f<union newunion>();
263    }
264  };
265  template struct S1<int>;
266
267  template <class T> struct S2 {
268    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 {
275    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 {};
283    void m() {
284      f<local>();
285    }
286  };
287  template struct S4<int>;
288
289  template <class T> struct S4a {
290    union local {};
291    void m() {
292      f<local>();
293    }
294  };
295  template struct S4a<int>;
296
297  template <class T> struct S5 {
298    enum local { nothing };
299    void m() {
300      f<local>();
301    }
302  };
303  template struct S5<int>;
304
305  template <class T> struct S7 {
306    enum class local { nothing };
307    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 { };
317    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 { };
326    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 };
335    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 };
344    void m() {
345      local x;
346      fff(&x);
347    }
348  };
349  template struct S03<int>;
350
351
352  template <class T> struct S04 {
353    void m() {
354      struct { } x;
355      fff(&x);
356    }
357  };
358  template struct S04<int>;
359
360  template <class T> struct S04a {
361    void m() {
362      union { } x;
363      fff(&x);
364    }
365  };
366  template struct S04a<int>;
367
368  template <class T> struct S05 {
369    void m() {
370      enum { nothing } x;
371      fff(&x);
372    }
373  };
374  template struct S05<int>;
375
376  template <class T> struct S06 {
377    void m() {
378      class { virtual void mmm() {} } x;
379      fff(&x);
380    }
381  };
382  template struct S06<int>;
383}
384
385namespace PR20625 {
386template <typename T>
387void 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
395void g() { f<void>(); }
396}
397
398
399namespace PR21332 {
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
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
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
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
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
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
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.
454namespace rdar23721638 {
455  struct A {
456    A(const char *) = delete;  // expected-note 2 {{explicitly marked deleted here}}
457  };
458
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
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
479namespace anon_union_default_member_init {
480  template<typename T> void f() {
481    struct S {
482      union {
483        int i = 0;
484      };
485    };
486  }
487  void g() { f<int>(); }
488}
489
CodeThinker, Enjoy your reading code