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