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