xref: /llvm-project/clang/test/PCH/cxx-templates.h (revision 9a88aa0e2b6d09c7c7932e14224632b2033ad403) 
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 template< typename > class Foo;
210 
211 template< typename T >
212 class Foo : protected T
213 {
214  public:
215   Foo& operator=( const Foo& other );
216 };
217 
218 template<typename...A> struct NestedExpansion {
219   template<typename...B> auto f(A...a, B...b) -> decltype(g(a + b...));
220 };
221 template struct NestedExpansion<char, char, char>;
222 
223 namespace rdar13135282 {
224 template < typename _Alloc >
225 void foo(_Alloc = _Alloc());
226 
227 template < bool > class __pool;
228 
229 template < template < bool > class _PoolTp >
230 struct __common_pool {
231   typedef _PoolTp < 0 > pool_type;
232 };
233 
234 template < template < bool > class _PoolTp >
235 struct __common_pool_base : __common_pool < _PoolTp > {};
236 
237 template < template < bool > class _PoolTp >
238 struct A : __common_pool_base < _PoolTp > {};
239 
240 template < typename _Poolp = A < __pool > >
241 struct __mt_alloc {
242   typedef typename _Poolp::pool_type __pool_type;
243   __mt_alloc() {
244     foo<__mt_alloc<> >();
245   }
246 };
247 }
248 
249 namespace PR13020 {
250 template<typename T>
251 void f() {
252  enum E {
253    enumerator
254  };
255 
256  T t = enumerator;
257 }
258 
259 template void f<int>();
260 }
261 
262 template<typename T> void doNotDeserialize() {}
263 template<typename T> struct ContainsDoNotDeserialize {
264   static int doNotDeserialize;
265 };
266 template<typename T> struct ContainsDoNotDeserialize2 {
267   static void doNotDeserialize();
268 };
269 template<typename T> int ContainsDoNotDeserialize<T>::doNotDeserialize = 0;
270 template<typename T> void ContainsDoNotDeserialize2<T>::doNotDeserialize() {}
271 
272 
273 template<typename T> void DependentSpecializedFunc(T x) { x.foo(); }
274 template<typename T> class DependentSpecializedFuncClass {
275   void foo() {}
276   friend void DependentSpecializedFunc<>(DependentSpecializedFuncClass);
277 };
278 
279 namespace cyclic_module_load {
280   // Reduced from a libc++ modules crasher.
281   namespace std {
282     template<class> class mask_array;
283     template<class> class valarray {
284     public:
285       valarray(const valarray &v);
286     };
287 
288     class gslice {
289       valarray<int> x;
290       valarray<int> stride() const { return x; }
291     };
292 
293     template<class> class mask_array {
294       template<class> friend class valarray;
295     };
296   }
297 }
298 
299 namespace local_extern {
300   template<typename T> int f() {
301     extern int arr[3];
302     {
303       extern T arr;
304       return sizeof(arr);
305     }
306   }
307   template<typename T> int g() {
308     extern int arr[3];
309     extern T arr;
310     return sizeof(arr);
311   }
312 }
313 
314 namespace rdar15468709a {
315   template<typename> struct decay {};
316 
317   template<typename FooParamTy> auto foo(FooParamTy fooParam) -> decltype(fooParam);
318   template<typename BarParamTy> auto bar(BarParamTy barParam) -> decay<decltype(barParam)>;
319 
320   struct B {};
321 
322   void crash() {
323     B some;
324     bar(some);
325   }
326 }
327 
328 namespace rdar15468709b {
329   template<typename> struct decay {};
330 
331   template<typename... Foos> int returnsInt(Foos... foos);
332 
333   template<typename... FooParamTy> auto foo(FooParamTy... fooParam) -> decltype(returnsInt(fooParam...));
334   template<typename... BarParamTy> auto bar(BarParamTy... barParam) -> decay<decltype(returnsInt(barParam...))>;
335 
336   struct B {};
337 
338   void crash() {
339     B some;
340     bar(some);
341   }
342 }
343 
344 namespace rdar15468709c {
345   template<typename> struct decay {};
346 
347   template<class... Foos> int returnsInt(Foos... foos);
348 
349   template<typename FooParamTy> void foo(FooParamTy fooParam) { decltype(fooParam) a; }
350   template<typename BarParamTy> auto bar(BarParamTy barParam) -> decay<decltype(barParam)>;
351 
352   struct B {};
353 
354   void crash() {
355     B some;
356     bar(some);
357   }
358 }
359 
360 namespace MemberSpecializationLocation {
361   template<typename T> struct A { static int n; };
362 }
363 
364 // https://bugs.llvm.org/show_bug.cgi?id=34728
365 namespace PR34728 {
366 
367 // case 1: defaulted `NonTypeTemplateParmDecl`, non-defaulted 2nd tpl param
368 template <int foo = 10, class T>
369 int func1(T const &);
370 
371 template <int foo, class T>
372 int func1(T const &) {
373   return foo;
374 }
375 
376 // case 2: defaulted `TemplateTypeParmDecl`, non-defaulted 2nd tpl param
377 template <class A = int, class B>
378 A func2(B const &);
379 
380 template <class A, class B>
381 A func2(B const &) {
382   return A(20.0f);
383 }
384 
385 // case 3: defaulted `TemplateTemplateParmDecl`, non-defaulted 2nd tpl param
386 template <class T>
387 struct Container { T const &item; };
388 
389 template <template <class> class C = Container, class D>
390 C<D> func3(D const &);
391 
392 template <template <class> class C, class D>
393 C<D> func3(D const &d) {
394   return Container<D>{d};
395 }
396 
397 } // end namespace PR34728
398 
399 namespace ClassScopeExplicitSpecializations {
400   template<int> struct A {
401     template<int> constexpr int f() const { return 1; }
402     template<> constexpr int f<0>() const { return 2; }
403   };
404 
405   template<> template<int> constexpr int A<0>::f() const { return 3; }
406   template<> template<> constexpr int A<0>::f<0>() const { return 4; }
407   template<> template<> constexpr int A<0>::f<1>() const { return 5; }
408 
409 #pragma clang diagnostic push
410 #pragma clang diagnostic ignored "-Winstantiation-after-specialization"
411   template int A<2>::f<0>() const;
412 #pragma clang diagnostic pop
413   template int A<2>::f<1>() const;
414   extern template int A<3>::f<0>() const;
415   extern template int A<3>::f<1>() const;
416 
417   template<int> struct B {
418     template<typename> static const int v = 1;
419     template<typename T> static const int v<T*> = 2;
420     template<> const int v<int> = 3;
421 
422     template<typename> static constexpr int w = 1;
423     template<typename T> static constexpr int w<T*> = 2;
424     template<> constexpr int w<int> = 3;
425   };
426 
427   template<> template<typename> constexpr int B<0>::v = 4;
428   template<> template<typename T> constexpr int B<0>::v<T*> = 5;
429   template<> template<typename T> constexpr int B<0>::v<T&> = 6;
430   // This is ill-formed: the initializer of v<int> is instantiated with the
431   // class.
432   //template<> template<> constexpr int B<0>::v<int> = 7;
433   template<> template<> constexpr int B<0>::v<float> = 8;
434 
435   template<> template<typename> constexpr int B<0>::w = 4;
436   template<> template<typename T> constexpr int B<0>::w<T*> = 5;
437   template<> template<typename T> constexpr int B<0>::w<T&> = 6;
438   template<> template<> constexpr int B<0>::w<int> = 7;
439   template<> template<> constexpr int B<0>::w<float> = 8;
440 }
441 
442 namespace DependentMemberExpr {
443   struct Base {
444     constexpr int setstate() { return 0; }
445   };
446   template<typename T> struct A : Base {
447     constexpr int f() { return Base::setstate(); }
448   };
449 }
450 
451 namespace DependentTemplateName {
452   template <template <class> class Template>
453   struct TakesClassTemplate {};
454 
455   template <class T>
456   TakesClassTemplate<T::template Member> getWithIdentifier();
457 }
458 
459 namespace ClassTemplateCycle {
460   // Create a cycle: the typedef T refers to A<0, 8>, whose template argument
461   // list refers back to T.
462   template<int, int> struct A;
463   using T = A<0, sizeof(void*)>;
464   template<int N> struct A<N, sizeof(T*)> {};
465   T t;
466 
467   // Create a cycle: the variable M refers to A<1, 1>, whose template argument
468   // list list refers back to M.
469   template<int, int> struct A;
470   const decltype(sizeof(A<1, 1>*)) M = 1;
471   template<int N> struct A<N, M> {};
472   A<1, 1> u;
473 }
474