clang/test/SemaTemplate/instantiate-init.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   2
   3 namespace std {
   4   template<typename T> struct initializer_list {
   5     T *p;
   6     __SIZE_TYPE__ n;
   7     initializer_list(T*, __SIZE_TYPE__);
   8   };
   9 }
  10
  11 struct X0 { // expected-note 8{{candidate}}
  12   X0(int*, float*); // expected-note 4{{candidate}}
  13 };
  14
  15 template<typename T, typename U>
  16 X0 f0(T t, U u) {
  17   X0 x0(t, u); // expected-error{{no matching}}
  18   return X0(t, u); // expected-error{{no matching}}
  19 }
  20
  21 void test_f0(int *ip, float *fp, double *dp) {
  22   f0(ip, fp);
  23   f0(ip, dp); // expected-note{{instantiation}}
  24 }
  25
  26 template<typename Ret, typename T, typename U>
  27 Ret f1(Ret *retty, T t, U u) {
  28   Ret r0(t, u); // expected-error{{no matching}}
  29   return Ret(t, u); // expected-error{{no matching}}
  30 }
  31
  32 void test_f1(X0 *x0, int *ip, float *fp, double *dp) {
  33   f1(x0, ip, fp);
  34   f1(x0, ip, dp); // expected-note{{instantiation}}
  35 }
  36
  37 namespace PR6457 {
  38   template <typename T> struct X { explicit X(T* p = 0) { }; };
  39   template <typename T> struct Y { Y(int, const T& x); };
  40   struct A { };
  41   template <typename T>
  42   struct B {
  43     B() : y(0, X<A>()) { }
  44     Y<X<A> > y;
  45   };
  46   B<int> b;
  47 }
  48
  49 namespace PR6657 {
  50   struct X
  51   {
  52     X (int, int) { }
  53   };
  54
  55   template <typename>
  56   void f0()
  57   {
  58     X x = X(0, 0);
  59   }
  60
  61   void f1()
  62   {
  63     f0<int>();
  64   }
  65 }
  66
  67 // Instantiate out-of-line definitions of static data members which complete
  68 // types through an initializer even when the only use of the member that would
  69 // cause instantiation is in an unevaluated context, but one requiring its
  70 // complete type.
  71 namespace PR10001 {
  72   template <typename T> struct S {
  73     static const int arr[];
  74     static const int x;
  75     static int f();
  76   };
  77
  78   template <typename T> const int S<T>::arr[] = { 1, 2, 3 };
  79   template <typename T> const int S<T>::x = sizeof(arr) / sizeof(arr[0]);
  80   template <typename T> int S<T>::f() { return x; }
  81
  82   int x = S<int>::f();
  83 }
  84
  85 namespace PR7985 {
  86   template<int N> struct integral_c { };
  87
  88   template <typename T, int N>
  89   integral_c<N> array_lengthof(T (&x)[N]) { return integral_c<N>(); } // expected-note 2{{candidate template ignored: could not match 'T[N]' against 'const Data<}}
  90
  91   template<typename T>
  92   struct Data {
  93     T x;
  94   };
  95
  96   template<typename T>
  97   struct Description {
  98     static const Data<T> data[];
  99   };
 100
 101   template<typename T>
 102   const Data<T> Description<T>::data[] = {{ 1 }}; // expected-error{{cannot initialize a member subobject of type 'int *' with an rvalue of type 'int'}}
 103
 104   template<>
 105   const Data<float*> Description<float*>::data[];
 106
 107   void test() {
 108     integral_c<1> ic1 = array_lengthof(Description<int>::data);
 109     (void)sizeof(array_lengthof(Description<float>::data));
 110
 111     (void)sizeof(array_lengthof( // expected-error{{no matching function for call to 'array_lengthof'}}
 112                           Description<int*>::data // expected-note{{in instantiation of static data member 'PR7985::Description<int *>::data' requested here}}
 113                           ));
 114
 115     array_lengthof(Description<float*>::data); // expected-error{{no matching function for call to 'array_lengthof'}}
 116   }
 117 }
 118
 119 namespace PR13064 {
 120   // Ensure that in-class direct-initialization is instantiated as
 121   // direct-initialization and likewise copy-initialization is instantiated as
 122   // copy-initialization.
 123   struct A { explicit A(int); }; // expected-note{{here}}
 124   template<typename T> struct B { T a { 0 }; };
 125   B<A> b;
 126   template <typename T> struct C { // expected-note {{in instantiation of default member initializer}}
 127     T a = {0}; // expected-error{{explicit}}
 128   };
 129   C<A> c; // expected-note {{in evaluation of exception spec}}
 130 }
 131
 132 namespace PR16903 {
 133   // Make sure we properly instantiate list-initialization.
 134   template<typename T>
 135   void fun (T it) {
 136         int m = 0;
 137         for (int i = 0; i < 4; ++i, ++it){
 138                 m |= long{char{*it}};
 139         }
 140   }
 141   int test() {
 142         char in[4] = {0,0,0,0};
 143         fun(in);
 144   }
 145 }
 146
 147 namespace ReturnStmtIsInitialization {
 148   struct X {
 149     X() {}
 150     X(const X &) = delete;
 151   };
 152   template<typename T> X f() { return {}; }
 153   auto &&x = f<void>();
 154 }
 155
 156 namespace InitListUpdate {
 157   struct A { int n; };
 158   using AA = A[1];
 159
 160   // Check that an init list update doesn't "lose" the pack-ness of an expression.
 161   template <int... N> void f() {
 162     g(AA{0, [0].n = N} ...); // expected-warning 3{{extension}} expected-note {{here}} expected-warning 3{{overrides prior init}} expected-note 3{{previous init}}
 163     g(AA{N, [0].n = 0} ...); // expected-warning 3{{extension}} expected-note {{here}} expected-warning 3{{overrides prior init}} expected-note 3{{previous init}}
 164   };
 165
 166   void g(AA, AA);
 167   void h() { f<1, 2>(); } // expected-note {{instantiation of}}
 168 }
 169
 170 namespace RebuildStdInitList {
 171   struct A { A(std::initializer_list<int>, int = 0) {} };
 172   struct B : A { using A::A; };
 173   struct PES { PES(B); };
 174
 175   // Check we can rebuild the use of the default argument here. This requires
 176   // going to the original (base class) constructor, because we don't copy
 177   // default arguments onto our fake derived class inherited constructors.
 178   template<typename U> void f() { PES({1, 2, 3}); }
 179   void g() { f<int>(); }
 180 }