clang/test/SemaTemplate/instantiate-expr-2.cpp

   1 // RUN: %clang_cc1 -fsyntax-only %s
   2 typedef char one_byte;
   3 typedef char (&two_bytes)[2];
   4 typedef char (&four_bytes)[4];
   5 typedef char (&eight_bytes)[8];
   6
   7 template<int N> struct A { };
   8
   9 namespace N1 {
  10   struct X { };
  11 }
  12
  13 namespace N2 {
  14   struct Y { };
  15
  16   two_bytes operator+(Y, Y);
  17 }
  18
  19 namespace N3 {
  20   struct Z { };
  21
  22   eight_bytes operator+(Z, Z);
  23 }
  24
  25 namespace N4 {
  26   one_byte operator+(N1::X, N2::Y);
  27
  28   template<typename T, typename U>
  29   struct BinOpOverload {
  30     typedef A<sizeof(T() + U())> type;
  31   };
  32 }
  33
  34 namespace N1 {
  35   four_bytes operator+(X, X);
  36 }
  37
  38 namespace N3 {
  39   eight_bytes operator+(Z, Z); // redeclaration
  40 }
  41
  42 void test_bin_op_overload(A<1> *a1, A<2> *a2, A<4> *a4, A<8> *a8) {
  43   typedef N4::BinOpOverload<N1::X, N2::Y>::type XY;
  44   XY *xy = a1;
  45   typedef N4::BinOpOverload<N1::X, N1::X>::type XX;
  46   XX *xx = a4;
  47   typedef N4::BinOpOverload<N2::Y, N2::Y>::type YY;
  48   YY *yy = a2;
  49   typedef N4::BinOpOverload<N3::Z, N3::Z>::type ZZ;
  50   ZZ *zz = a8;
  51 }
  52
  53 namespace N3 {
  54   eight_bytes operator-(::N3::Z);
  55 }
  56
  57 namespace N4 {
  58   template<typename T>
  59   struct UnaryOpOverload {
  60     typedef A<sizeof(-T())> type;
  61   };
  62 }
  63
  64 void test_unary_op_overload(A<8> *a8) {
  65   typedef N4::UnaryOpOverload<N3::Z>::type UZ;
  66   UZ *uz = a8;
  67 }
  68
  69 /*
  70 namespace N5 {
  71   template<int I>
  72   struct Lookup {
  73     enum { val = I, more = val + 1 };
  74   };
  75
  76   template<bool B>
  77   struct Cond {
  78     enum Junk { is = B ? Lookup<B>::more : Lookup<Lookup<B+1>::more>::val };
  79   };
  80
  81   enum { resultT = Cond<true>::is,
  82          resultF = Cond<false>::is };
  83 }
  84 */
  85
  86 namespace N6 {
  87   // non-typedependent
  88   template<int I>
  89   struct Lookup {};
  90
  91   template<bool B, typename T, typename E>
  92   struct Cond {
  93     typedef Lookup<B ? sizeof(T) : sizeof(E)> True;
  94     typedef Lookup<!B ? sizeof(T) : sizeof(E)> False;
  95   };
  96
  97   typedef Cond<true, int, char>::True True;
  98   typedef Cond<true, int, char>::False False;
  99
 100   // check that we have the right types
 101   Lookup<1> const &L1(False());
 102   Lookup<sizeof(int)> const &L2(True());
 103 }
 104
 105
 106 namespace N7 {
 107   // type dependent
 108   template<int I>
 109   struct Lookup {};
 110
 111   template<bool B, typename T, typename E>
 112   struct Cond {
 113     T foo() { return B ? T() : E(); }
 114     typedef Lookup<sizeof(B ? T() : E())> Type;
 115   };
 116
 117   //Cond<true, int*, double> C; // Errors
 118   //int V(C.foo()); // Errors
 119   //typedef Cond<true, int*, double>::Type Type; // Errors
 120   typedef Cond<true, int, double>::Type Type;
 121 }
 122
 123 template<typename T, unsigned long N> struct IntegralConstant { };
 124
 125 template<typename T>
 126 struct X0 {
 127   void f(T x, IntegralConstant<T, sizeof(x)>);
 128 };
 129
 130 void test_X0(X0<int> x, IntegralConstant<int, sizeof(int)> ic) {
 131   x.f(5,ic);
 132 }
 133
 134 namespace N8 {
 135   struct X {
 136     X operator+(const X&) const;
 137   };
 138
 139   template<typename T>
 140   T test_plus(const T* xp, const T& x, const T& y) {
 141     x.operator+(y);
 142     return xp->operator+(y);
 143   }
 144
 145   void test_test_plus(X x) {
 146     test_plus(&x, x, x);
 147   }
 148 }
 149
 150 namespace N9 {
 151   struct A {
 152     bool operator==(int value);
 153   };
 154
 155   template<typename T> struct B {
 156     bool f(A a) {
 157       return a == 1;
 158     }
 159   };
 160
 161   template struct B<int>;
 162 }
 163
 164 namespace N10 {
 165   template <typename T>
 166   class A {
 167     struct X { };
 168
 169   public:
 170     ~A() {
 171       f(reinterpret_cast<X *>(0), reinterpret_cast<X *>(0));
 172     }
 173
 174   private:
 175     void f(X *);
 176     void f(X *, X *);
 177   };
 178
 179   template class A<int>;
 180 }
 181
 182 namespace N12 {
 183   // PR5224
 184   template<typename T>
 185   struct A { typedef int t0; };
 186
 187   struct C  {
 188     C(int);
 189
 190     template<typename T>
 191     static C *f0(T a0) {return new C((typename A<T>::t0) 1);   }
 192   };
 193
 194   void f0(int **a) { C::f0(a); }
 195 }
 196
 197 namespace PR7202 {
 198   template<typename U, typename T>
 199   struct meta {
 200     typedef T type;
 201   };
 202
 203   struct X {
 204     struct dummy;
 205
 206     template<typename T>
 207     X(T, typename meta<T, dummy*>::type = 0);
 208
 209     template<typename T, typename A>
 210     X(T, A);
 211   };
 212
 213   template<typename T>
 214   struct Z { };
 215
 216   template<typename T> Z<T> g(T);
 217
 218   struct Y {
 219     template<typename T>
 220     void f(T t) {
 221       new X(g(*this));
 222     }
 223   };
 224
 225   template void Y::f(int);
 226 }
 227
 228 namespace N13 {
 229   class A{
 230     A(const A&);
 231
 232   public:
 233     ~A();
 234     A(int);
 235     template<typename T> A &operator<<(const T&);
 236   };
 237
 238   template<typename T>
 239   void f(T t) {
 240     A(17) << t;
 241   }
 242
 243   template void f(int);
 244
 245 }