clang/test/SemaTemplate/instantiate-member-template.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2
   3 template<typename T>
   4 struct X0 {
   5   template<typename U> T f0(U);
   6   template<typename U> U& f1(T*, U); // expected-error{{pointer to a reference}} \
   7                                      // expected-note{{candidate}}
   8 };
   9
  10 X0<int> x0i;
  11 X0<void> x0v;
  12 X0<int&> x0ir; // expected-note{{instantiation}}
  13
  14 void test_X0(int *ip, double *dp) {
  15   X0<int> xi;
  16   int i1 = xi.f0(ip);
  17   double *&dpr = xi.f1(ip, dp);
  18   xi.f1(dp, dp); // expected-error{{no matching}}
  19
  20   X0<void> xv;
  21   double *&dpr2 = xv.f1(ip, dp);
  22 }
  23
  24 template<typename T>
  25 struct X1 {
  26   template<typename U>
  27   struct Inner0 {
  28     U x;
  29     T y; // expected-error{{void}}
  30   };
  31
  32   template<typename U>
  33   struct Inner1 {
  34     U x; // expected-error{{void}}
  35     T y;
  36   };
  37
  38   template<typename U>
  39   struct Inner2 {
  40     struct SuperInner {
  41       U z; // expected-error{{void}}
  42     };
  43   };
  44
  45   template<typename U>
  46   struct Inner3 {
  47     void f0(T t, U u) { // expected-note{{passing argument to parameter 't' here}}
  48       (void)(t + u); // expected-error{{invalid operands}}
  49     }
  50
  51     template<typename V>
  52     V f1(T t, U u, V) {
  53       return t + u; // expected-error{{cannot initialize return object}}
  54     }
  55   };
  56
  57   template<typename U>
  58   struct Inner4;
  59 };
  60
  61 template<typename T>
  62 template<typename U>
  63 struct X1<T>::Inner4 {
  64   template<typename V>
  65   V f2(T t, U u, V);
  66
  67   static U value;
  68 };
  69
  70 template<typename T>
  71 template<typename U>
  72 U X1<T>::Inner4<U>::value; // expected-error{{reference variable}}
  73
  74 template<typename T>
  75 template<typename U>
  76 template<typename V>
  77 V X1<T>::Inner4<U>::f2(T t, U u, V) {
  78   return t + u; // expected-error{{cannot initialize return object}}
  79 }
  80
  81 void test_X1(int *ip, int i, double *dp) {
  82   X1<void>::Inner0<int> *xvip; // okay
  83   X1<void>::Inner0<int> xvi; // expected-note{{instantiation}}
  84
  85   X1<int>::Inner1<void> *xivp; // okay
  86   X1<int>::Inner1<void> xiv; // expected-note{{instantiation}}
  87
  88   X1<int>::Inner2<void>::SuperInner *xisivp; // okay
  89   X1<int>::Inner2<void>::SuperInner xisiv; // expected-note{{instantiation}}
  90
  91   X1<int*>::Inner3<int> id3;
  92   id3.f0(ip, i);
  93   id3.f0(dp, i); // expected-error{{cannot initialize a parameter of type 'int *' with an lvalue of type 'double *'}}
  94   id3.f1(ip, i, ip);
  95   id3.f1(ip, i, dp); // expected-note{{instantiation}}
  96
  97   X1<int*>::Inner3<double*> id3b;
  98   id3b.f0(ip, dp); // expected-note{{instantiation}}
  99
 100   X1<int*>::Inner4<int> id4;
 101   id4.f2(ip, i, dp); // expected-note{{instantiation}}
 102
 103   X1<int*>::Inner4<int>::value = 17;
 104   i = X1<int*>::Inner4<int&>::value; // expected-note{{instantiation}}
 105 }
 106
 107
 108 template<typename T>
 109 struct X2 {
 110   template<T *Ptr> // expected-error{{pointer to a reference}}
 111   struct Inner;
 112
 113   template<T Value> // expected-error{{cannot have type 'float'}}
 114   struct Inner2;
 115 };
 116
 117 X2<int&> x2a; // expected-note{{instantiation}}
 118 X2<float> x2b; // expected-note{{instantiation}}
 119
 120 namespace N0 {
 121   template<typename T>
 122   struct X0 { };
 123
 124   struct X1 {
 125     template<typename T> void f(X0<T>& vals) { g(vals); }
 126     template<typename T> void g(X0<T>& vals) { }
 127   };
 128
 129   void test(X1 x1, X0<int> x0i, X0<long> x0l) {
 130     x1.f(x0i);
 131     x1.f(x0l);
 132   }
 133 }
 134
 135 namespace PR6239 {
 136   template <typename T>
 137   struct X0 {
 138     class type {
 139       typedef T E;
 140       template <E e>  // subsitute T for E and bug goes away
 141       struct sfinae {  };
 142
 143       template <class U>
 144       typename sfinae<&U::operator=>::type test(int);
 145     };
 146   };
 147
 148   template <typename T>
 149   struct X1 {
 150     typedef T E;
 151     template <E e>  // subsitute T for E and bug goes away
 152     struct sfinae {  };
 153
 154     template <class U>
 155     typename sfinae<&U::operator=>::type test(int);
 156   };
 157
 158 }
 159
 160 namespace PR7587 {
 161   template<typename> class X0;
 162   template<typename> struct X1;
 163   template<typename> class X2;
 164
 165   template<typename T> class X3
 166   {
 167     template<
 168       template<typename> class TT,
 169       typename U = typename X1<T>::type
 170     >
 171     struct Inner {
 172       typedef X2<TT<typename X1<T>::type> > Type;
 173     };
 174
 175     const typename Inner<X0>::Type minCoeff() const;
 176   };
 177
 178   template<typename T> class X3<T*>
 179   {
 180     template<
 181       template<typename> class TT,
 182       typename U = typename X1<T>::type
 183     >
 184     struct Inner {
 185       typedef X2<TT<typename X1<T>::type> > Type;
 186     };
 187
 188     const typename Inner<X0>::Type minCoeff() const;
 189   };
 190
 191 }
 192
 193 namespace PR7669 {
 194   template<class> struct X {
 195     template<class> struct Y {
 196       template<int,class> struct Z;
 197       template<int Dummy> struct Z<Dummy,int> {};
 198     };
 199   };
 200
 201   void a()
 202   {
 203     X<int>::Y<int>::Z<0,int>();
 204   }
 205 }
 206
 207 namespace PR8489 {
 208   template <typename CT>
 209   class C {
 210     template<typename FT>
 211     void F() {} // expected-note{{FT}}
 212   };
 213   void f() {
 214     C<int> c;
 215     c.F(); // expected-error{{no matching member function}}
 216   }
 217 }
 218
 219 namespace rdar8986308 {
 220   template <bool> struct __static_assert_test;
 221   template <> struct __static_assert_test<true> {};
 222   template <unsigned> struct __static_assert_check {};
 223
 224   namespace std {
 225
 226     template <class _Tp, class _Up>
 227     struct __has_rebind
 228     {
 229     private:
 230       struct __two {char _; char __;};
 231       template <class _Xp> static __two __test(...);
 232       template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
 233     public:
 234       static const bool value = sizeof(__test<_Tp>(0)) == 1;
 235     };
 236
 237   }
 238
 239   template <class T> struct B1 {};
 240
 241   template <class T>
 242   struct B
 243   {
 244     template <class U> struct rebind {typedef B1<U> other;};
 245   };
 246
 247   template <class T, class U> struct D1 {};
 248
 249   template <class T, class U>
 250   struct D
 251   {
 252     template <class V> struct rebind {typedef D1<V, U> other;};
 253   };
 254
 255   int main()
 256   {
 257     typedef __static_assert_check<sizeof(__static_assert_test<((std::__has_rebind<B<int>, double>::value))>)> __t64;
 258     typedef __static_assert_check<sizeof(__static_assert_test<((std::__has_rebind<D<char, int>, double>::value))>)> __t64;
 259   }
 260
 261 }