clang/test/PCH/cxx-templates.h

   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 {
   8   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<> static 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<> static 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 }