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 // <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
