1// RUN: %clang_cc1 -verify -std=c++11 %s
2template<typename T>
3void f0() {
4  struct X;
5  typedef struct Y {
6    T (X::* f1())(int) { return 0; }
7  } Y2;
8
9  Y2 y = Y();
10}
11
12template void f0<int>();
13
14// PR5764
15namespace PR5764 {
16  struct X {
17    template <typename T>
18    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
30  void test(X x) {
31    x.Bar<int>();
32  }
33}
34
35// Instantiation of local classes with virtual functions.
36namespace local_class_with_virtual_functions {
37  template <typename T> struct X { };
38  template <typename T> struct Y { };
39
40  template <typename T>
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 { };
51  void test() { f<S>(); }
52}
53
54namespace PR8801 {
55  template<typename T>
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
69namespace TemplatePacksAndLambdas {
70  template <typename ...T> int g(T...);
71  struct S {
72    template <typename ...T> static void f(int f = g([]{ static T t; return ++t; }()...)) {}
73  };
74  void h() { S::f<int, int, int>(); }
75}
76
77namespace PR9685 {
78  template <class Thing> void forEach(Thing t) { t.func(); }
79
80  template <typename T> void doIt() {
81    struct Functor {
82      void func() { (void)i; }
83      int i;
84    };
85
86    forEach(Functor());
87  }
88
89  void call() {
90    doIt<int>();
91  }
92}
93
94namespace PR12702 {
95  struct S {
96    template <typename F> bool apply(F f) { return f(); }
97  };
98
99  template <typename> struct T {
100    void foo() {
101      struct F {
102        int x;
103
104        bool operator()() { return x == 0; }
105      };
106
107      S().apply(F());
108    }
109  };
110
111  void call() { T<int>().foo(); }
112}
113
114namespace PR17139 {
115  template <class T> void foo(const T &t) { t.foo(); }
116
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
125  void go() {}
126
127  void test() { bar(go); }
128}
129
130namespace PR17740 {
131class C {
132public:
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
138template <typename T> void C::foo(T function) { function(); }
139
140template <typename T> void C::bar(T function) {
141  foo([&function]() { function(); });
142}
143
144template <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
158void call() {
159  C::func([]() {});
160}
161}
162
163namespace PR14373 {
164  struct function {
165    template <typename _Functor> function(_Functor __f) { __f(); }
166  };
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 {
176    void operator()() const {}
177  };
178  int call() {
179    exec_func(Type());
180    return 0;
181  }
182}
183
184namespace PR18907 {
185template <typename>
186class C : public C<int> {}; // expected-error{{within its own definition}}
187
188template <typename X>
189void F() {
190  struct A : C<X> {};
191}
192
193struct B {
194  void f() { F<int>(); }
195};
196}
197