1 // Header for PCH test cxx-templates.cpp
2 
3 template <typename T1, typename T2>
4 struct S;
5 
6 template <typename T1, typename T2>
7 struct S {
SS8   S() { }
9   static void templ();
10 };
11 
12 template <typename T>
13 struct S<int, T> {
14     static void partial();
15 };
16 
17 template <>
18 struct S<int, float> {
19     static void explicit_special();
20 };
21 
22 template <int x>
23 int tmpl_f2() { return x; }
24 
25 template <typename T, int y>
26 T templ_f(T x) {
27   int z = templ_f<int, 5>(3);
28   z = tmpl_f2<y+2>();
29   T data[y];
30   return x+y;
31 }
32 
33 void govl(int);
34 void govl(char);
35 
36 template <typename T>
37 struct Unresolv {
38   void f() {
39     govl(T());
40   }
41 };
42 
43 template <typename T>
44 struct Dep {
45   typedef typename T::type Ty;
46   void f() {
47     Ty x = Ty();
48     T::my_f();
49     int y = T::template my_templf<int>(0);
50     ovl(y);
51   }
52 
53   void ovl(int);
54   void ovl(float);
55 };
56 
57 template<typename T, typename A1>
58 inline T make_a(const A1& a1) {
59   T::depend_declref();
60   return T(a1);
61 }
62 
63 template <class T> class UseBase {
64   void foo();
65   typedef int bar;
66 };
67 
68 template <class T> class UseA : public UseBase<T> {
69   using UseBase<T>::foo;
70   using typename UseBase<T>::bar;
71 };
72 
73 template <class T> class Sub : public UseBase<int> { };
74 
75 template <class _Ret, class _Tp>
76   class mem_fun_t
77   {
78   public:
79     explicit
80     mem_fun_t(_Ret (_Tp::*__pf)())
81      {}
82 
83   private:
84     _Ret (_Tp::*_M_f)();
85   };
86 
87 template<unsigned N>
88 bool isInt(int x);
89 
90 template<> bool isInt<8>(int x) {
91   try { ++x; } catch(...) { --x; }
92   return true;
93 }
94 
95 template<typename _CharT>
96 int __copy_streambufs_eof(_CharT);
97 
98 class basic_streambuf
99 {
100   void m() { }
101   friend int __copy_streambufs_eof<>(int);
102 };
103 
104 // PR 7660
105 template<typename T> struct S_PR7660 { void g(void (*)(T)); };
106  template<> void S_PR7660<int>::g(void(*)(int)) {}
107 
108 // PR 7670
109 template<typename> class C_PR7670;
110 template<> class C_PR7670<int>;
111 template<> class C_PR7670<int>;
112 
113 template <bool B>
114 struct S2 {
115     static bool V;
116 };
117 
118 extern template class S2<true>;
119 
120 template <typename T>
121 struct S3 {
122     void m();
123 };
124 
125 template <typename T>
126 inline void S3<T>::m() { }
127 
128 template <typename T>
129 struct S4 {
130     void m() { }
131 };
132 extern template struct S4<int>;
133 
134 void S4ImplicitInst() {
135     S4<int> s;
136     s.m();
137 }
138 
139 struct S5 {
140   S5(int x);
141 };
142 
143 struct TS5 {
144   S5 s;
145   template <typename T>
146   TS5(T y) : s(y) {}
147 };
148 
149 // PR 8134
150 template<class T> void f_PR8134(T);
151 template<class T> void f_PR8134(T);
152 void g_PR8134() { f_PR8134(0); f_PR8134('x'); }
153 
154 // rdar8580149
155 template <typename T>
156 struct S6;
157 
158 template <typename T, unsigned N>
159 struct S6<const T [N]>
160 {
161 private:
162    typedef const T t1[N];
163 public:
164    typedef t1& t2;
165 };
166 
167 template<typename T>
168   struct S7;
169 
170 template<unsigned N>
171 struct S7<int[N]> : S6<const int[N]> { };
172 
173 // Zero-length template argument lists
174 namespace ZeroLengthExplicitTemplateArgs {
175   template<typename T> void h();
176 
177   struct Y {
178     template<typename T> void f();
179   };
180 
181   template<typename T>
182     void f(T *ptr) {
183     T::template g<>(17);
184     ptr->template g2<>(17);
185     h<T>();
186     h<int>();
187     Y y;
188     y.f<int>();
189   }
190 
191   struct X {
192     template<typename T> static void g(T);
193     template<typename T> void g2(T);
194   };
195 }
196 
197 namespace NonTypeTemplateParmContext {
198   template<typename T, int inlineCapacity = 0> class Vector { };
199 
200   struct String {
201     template<int inlineCapacity>
202     static String adopt(Vector<char, inlineCapacity>&);
203   };
204 
205   template<int inlineCapacity>
206     inline bool equalIgnoringNullity(const Vector<char, inlineCapacity>& a, const String& b) { return false; }
207 }
208 
209 // <rdar://problem/11112464>
210 template< typename > class Foo;
211 
212 template< typename T >
213 class Foo : protected T
214 {
215  public:
216   Foo& operator=( const Foo& other );
217 };
218 
219 template<typename...A> struct NestedExpansion {
220   template<typename...B> auto f(A...a, B...b) -> decltype(g(a + b...));
221 };
222 template struct NestedExpansion<char, char, char>;
223 
224 namespace rdar13135282 {
225 template < typename _Alloc >
226 void foo(_Alloc = _Alloc());
227 
228 template < bool > class __pool;
229 
230 template < template < bool > class _PoolTp >
231 struct __common_pool {
232   typedef _PoolTp < 0 > pool_type;
233 };
234 
235 template < template < bool > class _PoolTp >
236 struct __common_pool_base : __common_pool < _PoolTp > {};
237 
238 template < template < bool > class _PoolTp >
239 struct A : __common_pool_base < _PoolTp > {};
240 
241 template < typename _Poolp = A < __pool > >
242 struct __mt_alloc {
243   typedef typename _Poolp::pool_type __pool_type;
244   __mt_alloc() {
245     foo<__mt_alloc<> >();
246   }
247 };
248 }
249 
250 namespace PR13020 {
251 template<typename T>
252 void f() {
253  enum E {
254    enumerator
255  };
256 
257  T t = enumerator;
258 }
259 
260 template void f<int>();
261 }
262 
263 template<typename T> void doNotDeserialize() {}
264 template<typename T> struct ContainsDoNotDeserialize {
265   static int doNotDeserialize;
266 };
267 template<typename T> struct ContainsDoNotDeserialize2 {
268   static void doNotDeserialize();
269 };
270 template<typename T> int ContainsDoNotDeserialize<T>::doNotDeserialize = 0;
271 template<typename T> void ContainsDoNotDeserialize2<T>::doNotDeserialize() {}
272 
273 
274 template<typename T> void DependentSpecializedFunc(T x) { x.foo(); }
275 template<typename T> class DependentSpecializedFuncClass {
276   void foo() {}
277   friend void DependentSpecializedFunc<>(DependentSpecializedFuncClass);
278 };
279 
280 namespace cyclic_module_load {
281   // Reduced from a libc++ modules crasher.
282   namespace std {
283     template<class> class mask_array;
284     template<class> class valarray {
285     public:
286       valarray(const valarray &v);
287     };
288 
289     class gslice {
290       valarray<int> x;
291       valarray<int> stride() const { return x; }
292     };
293 
294     template<class> class mask_array {
295       template<class> friend class valarray;
296     };
297   }
298 }
299 
300 namespace local_extern {
301   template<typename T> int f() {
302     extern int arr[3];
303     {
304       extern T arr;
305       return sizeof(arr);
306     }
307   }
308   template<typename T> int g() {
309     extern int arr[3];
310     extern T arr;
311     return sizeof(arr);
312   }
313 }
314 
315 namespace rdar15468709a {
316   template<typename> struct decay {};
317 
318   template<typename FooParamTy> auto foo(FooParamTy fooParam) -> decltype(fooParam);
319   template<typename BarParamTy> auto bar(BarParamTy barParam) -> decay<decltype(barParam)>;
320 
321   struct B {};
322 
323   void crash() {
324     B some;
325     bar(some);
326   }
327 }
328 
329 namespace rdar15468709b {
330   template<typename> struct decay {};
331 
332   template<typename... Foos> int returnsInt(Foos... foos);
333 
334   template<typename... FooParamTy> auto foo(FooParamTy... fooParam) -> decltype(returnsInt(fooParam...));
335   template<typename... BarParamTy> auto bar(BarParamTy... barParam) -> decay<decltype(returnsInt(barParam...))>;
336 
337   struct B {};
338 
339   void crash() {
340     B some;
341     bar(some);
342   }
343 }
344 
345 namespace rdar15468709c {
346   template<typename> struct decay {};
347 
348   template<class... Foos> int returnsInt(Foos... foos);
349 
350   template<typename FooParamTy> void foo(FooParamTy fooParam) { decltype(fooParam) a; }
351   template<typename BarParamTy> auto bar(BarParamTy barParam) -> decay<decltype(barParam)>;
352 
353   struct B {};
354 
355   void crash() {
356     B some;
357     bar(some);
358   }
359 }
360 
361 namespace MemberSpecializationLocation {
362   template<typename T> struct A { static int n; };
363 }
364 
365 // https://bugs.llvm.org/show_bug.cgi?id=34728
366 namespace PR34728 {
367 
368 // case 1: defaulted `NonTypeTemplateParmDecl`, non-defaulted 2nd tpl param
369 template <int foo = 10, class T>
370 int func1(T const &);
371 
372 template <int foo, class T>
373 int func1(T const &) {
374   return foo;
375 }
376 
377 // case 2: defaulted `TemplateTypeParmDecl`, non-defaulted 2nd tpl param
378 template <class A = int, class B>
379 A func2(B const &);
380 
381 template <class A, class B>
382 A func2(B const &) {
383   return A(20.0f);
384 }
385 
386 // case 3: defaulted `TemplateTemplateParmDecl`, non-defaulted 2nd tpl param
387 template <class T>
388 struct Container { T const &item; };
389 
390 template <template <class> class C = Container, class D>
391 C<D> func3(D const &);
392 
393 template <template <class> class C, class D>
394 C<D> func3(D const &d) {
395   return Container<D>{d};
396 }
397 
398 } // end namespace PR34728
399 
400 namespace ClassScopeExplicitSpecializations {
401   template<int> struct A {
402     template<int> constexpr int f() const { return 1; }
403     template<> constexpr int f<0>() const { return 2; }
404   };
405 
406   template<> template<int> constexpr int A<0>::f() const { return 3; }
407   template<> template<> constexpr int A<0>::f<0>() const { return 4; }
408   template<> template<> constexpr int A<0>::f<1>() const { return 5; }
409 
410 #pragma clang diagnostic push
411 #pragma clang diagnostic ignored "-Winstantiation-after-specialization"
412   template int A<2>::f<0>() const;
413 #pragma clang diagnostic pop
414   template int A<2>::f<1>() const;
415   extern template int A<3>::f<0>() const;
416   extern template int A<3>::f<1>() const;
417 
418   template<int> struct B {
419     template<typename> static const int v = 1;
420     template<typename T> static const int v<T*> = 2;
421     template<> static const int v<int> = 3;
422 
423     template<typename> static constexpr int w = 1;
424     template<typename T> static constexpr int w<T*> = 2;
425     template<> static constexpr int w<int> = 3;
426   };
427 
428   template<> template<typename> constexpr int B<0>::v = 4;
429   template<> template<typename T> constexpr int B<0>::v<T*> = 5;
430   template<> template<typename T> constexpr int B<0>::v<T&> = 6;
431   // This is ill-formed: the initializer of v<int> is instantiated with the
432   // class.
433   //template<> template<> constexpr int B<0>::v<int> = 7;
434   template<> template<> constexpr int B<0>::v<float> = 8;
435 
436   template<> template<typename> constexpr int B<0>::w = 4;
437   template<> template<typename T> constexpr int B<0>::w<T*> = 5;
438   template<> template<typename T> constexpr int B<0>::w<T&> = 6;
439   template<> template<> constexpr int B<0>::w<int> = 7;
440   template<> template<> constexpr int B<0>::w<float> = 8;
441 }
442 
443 namespace DependentMemberExpr {
444   struct Base {
445     constexpr int setstate() { return 0; }
446   };
447   template<typename T> struct A : Base {
448     constexpr int f() { return Base::setstate(); }
449   };
450 }
451 
452 namespace DependentTemplateName {
453   template <template <class> class Template>
454   struct TakesClassTemplate {};
455 
456   template <class T>
457   TakesClassTemplate<T::template Member> getWithIdentifier();
458 }
459 
460 namespace ClassTemplateCycle {
461   // Create a cycle: the typedef T refers to A<0, 8>, whose template argument
462   // list refers back to T.
463   template<int, int> struct A;
464   using T = A<0, sizeof(void*)>;
465   template<int N> struct A<N, sizeof(T*)> {};
466   T t;
467 
468   // Create a cycle: the variable M refers to A<1, 1>, whose template argument
469   // list list refers back to M.
470   template<int, int> struct A;
471   const decltype(sizeof(A<1, 1>*)) M = 1;
472   template<int N> struct A<N, M> {};
473   A<1, 1> u;
474 }
475