Home | History | Annotate | Download | only in PCH
      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