test/SemaTemplate/instantiate-member-template.cpp

   1 // RUN: clang-cc -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) {
  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{{incompatible type}}
  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{{incompatible type}}
  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{{incompatible type}}
  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}}