1 // RUN: %clang_cc1 -verify -std=c++11 %s
2 template<typename T>
f0()3 void f0() {
4   struct X;
5   typedef struct Y {
6     T (X::* f1())(int) { return 0; }
7   } Y2;
8 
9   Y2 y = Y();
10 }
11 
12 template void f0<int>();
13 
14 // PR5764
15 namespace PR5764 {
16   struct X {
17     template <typename T>
BarPR5764::X18     void Bar() {
19       typedef T ValueType;
20       struct Y {
21         Y() { V = ValueType(); }
22 
23         ValueType V;
24       };
25 
26       Y y;
27     }
28   };
29 
test(X x)30   void test(X x) {
31     x.Bar<int>();
32   }
33 }
34 
35 // Instantiation of local classes with virtual functions.
36 namespace local_class_with_virtual_functions {
37   template <typename T> struct X { };
38   template <typename T> struct Y { };
39 
40   template <typename T>
f()41   void f() {
42     struct Z : public X<Y<T>*> {
43       virtual void g(Y<T>* y) { }
44       void g2(int x) {(void)x;}
45     };
46     Z z;
47     (void)z;
48   }
49 
50   struct S { };
test()51   void test() { f<S>(); }
52 }
53 
54 namespace PR8801 {
55   template<typename T>
foo()56   void foo() {
57     class X;
58     typedef int (X::*pmf_type)();
59     class X : public T { };
60 
61     pmf_type pmf = &T::foo;
62   }
63 
64   struct Y { int foo(); };
65 
66   template void foo<Y>();
67 }
68 
69 namespace TemplatePacksAndLambdas {
70   template <typename ...T> int g(T...);
71   struct S {
fTemplatePacksAndLambdas::S72     template <typename ...T> static void f(int f = g([]{ static T t; return ++t; }()...)) {}
73   };
h()74   void h() { S::f<int, int, int>(); }
75 }
76 
77 namespace PR9685 {
forEach(Thing t)78   template <class Thing> void forEach(Thing t) { t.func(); }
79 
doIt()80   template <typename T> void doIt() {
81     struct Functor {
82       void func() { (void)i; }
83       int i;
84     };
85 
86     forEach(Functor());
87   }
88 
call()89   void call() {
90     doIt<int>();
91   }
92 }
93 
94 namespace PR12702 {
95   struct S {
applyPR12702::S96     template <typename F> bool apply(F f) { return f(); }
97   };
98 
99   template <typename> struct T {
fooPR12702::T100     void foo() {
101       struct F {
102         int x;
103 
104         bool operator()() { return x == 0; }
105       };
106 
107       S().apply(F());
108     }
109   };
110 
call()111   void call() { T<int>().foo(); }
112 }
113 
114 namespace PR17139 {
foo(const T & t)115   template <class T> void foo(const T &t) { t.foo(); }
116 
bar(F * f)117   template <class F> void bar(F *f) {
118     struct B {
119       F *fn;
120       void foo() const { fn(); }
121     } b = { f };
122     foo(b);
123   }
124 
go()125   void go() {}
126 
test()127   void test() { bar(go); }
128 }
129 
130 namespace PR17740 {
131 class C {
132 public:
133   template <typename T> static void foo(T function);
134   template <typename T> static void bar(T function);
135   template <typename T> static void func(T function);
136 };
137 
foo(T function)138 template <typename T> void C::foo(T function) { function(); }
139 
bar(T function)140 template <typename T> void C::bar(T function) {
141   foo([&function]() { function(); });
142 }
143 
func(T function)144 template <typename T> void C::func(T function) {
145   struct Struct {
146     T mFunction;
147 
148     Struct(T function) : mFunction(function) {};
149 
150     void operator()() {
151       mFunction();
152     };
153   };
154 
155   bar(Struct(function));
156 }
157 
call()158 void call() {
159   C::func([]() {});
160 }
161 }
162 
163 namespace PR14373 {
164   struct function {
functionPR14373::function165     template <typename _Functor> function(_Functor __f) { __f(); }
166   };
exec_func(Func f)167   template <typename Func> function exec_func(Func f) {
168     struct functor {
169       functor(Func f) : func(f) {}
170       void operator()() const { func(); }
171       Func func;
172     };
173     return functor(f);
174   }
175   struct Type {
operator ()PR14373::Type176     void operator()() const {}
177   };
call()178   int call() {
179     exec_func(Type());
180     return 0;
181   }
182 }
183 
184 namespace PR18907 {
185 template <typename>
186 class C : public C<int> {}; // expected-error{{within its own definition}}
187 
188 template <typename X>
F()189 void F() {
190   struct A : C<X> {};
191 }
192 
193 struct B {
fPR18907::B194   void f() { F<int>(); }
195 };
196 }
197