src/llvm/tools/clang/test/SemaTemplate/instantiate-expr-4.cpp

   1 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
   2
   3 // ---------------------------------------------------------------------
   4 // C++ Functional Casts
   5 // ---------------------------------------------------------------------
   6 template<int N>
   7 struct ValueInit0 {
   8   int f() {
   9     return int();
  10   }
  11 };
  12
  13 template struct ValueInit0<5>;
  14
  15 template<int N>
  16 struct FunctionalCast0 {
  17   int f() {
  18     return int(N);
  19   }
  20 };
  21
  22 template struct FunctionalCast0<5>;
  23
  24 struct X { // expected-note 3 {{candidate constructor (the implicit copy constructor)}}
  25   X(int, int); // expected-note 3 {{candidate constructor}}
  26 };
  27
  28 template<int N, int M>
  29 struct BuildTemporary0 {
  30   X f() {
  31     return X(N, M);
  32   }
  33 };
  34
  35 template struct BuildTemporary0<5, 7>;
  36
  37 template<int N, int M>
  38 struct Temporaries0 {
  39   void f() {
  40     (void)X(N, M);
  41   }
  42 };
  43
  44 template struct Temporaries0<5, 7>;
  45
  46 // Ensure that both the constructor and the destructor are instantiated by
  47 // checking for parse errors from each.
  48 template<int N> struct BadX {
  49   BadX() { int a[-N]; } // expected-error {{array with a negative size}}
  50   ~BadX() { int a[-N]; } // expected-error {{array with a negative size}}
  51 };
  52
  53 template<int N>
  54 struct PR6671 {
  55   void f() { (void)BadX<1>(); } // expected-note 2 {{instantiation}}
  56 };
  57 template struct PR6671<1>;
  58
  59 // ---------------------------------------------------------------------
  60 // new/delete expressions
  61 // ---------------------------------------------------------------------
  62 struct Y { };
  63
  64 template<typename T>
  65 struct New0 {
  66   T* f(bool x) {
  67     if (x)
  68       return new T; // expected-error{{no matching}}
  69     else
  70       return new T();
  71   }
  72 };
  73
  74 template struct New0<int>;
  75 template struct New0<Y>;
  76 template struct New0<X>; // expected-note{{instantiation}}
  77
  78 template<typename T, typename Arg1>
  79 struct New1 {
  80   T* f(bool x, Arg1 a1) {
  81     return new T(a1); // expected-error{{no matching}}
  82   }
  83 };
  84
  85 template struct New1<int, float>;
  86 template struct New1<Y, Y>;
  87 template struct New1<X, Y>; // expected-note{{instantiation}}
  88
  89 template<typename T, typename Arg1, typename Arg2>
  90 struct New2 {
  91   T* f(bool x, Arg1 a1, Arg2 a2) {
  92     return new T(a1, a2); // expected-error{{no matching}}
  93   }
  94 };
  95
  96 template struct New2<X, int, float>;
  97 template struct New2<X, int, int*>; // expected-note{{instantiation}}
  98 // FIXME: template struct New2<int, int, float>;
  99
 100 // PR5833
 101 struct New3 {
 102   New3();
 103
 104   void *operator new[](__SIZE_TYPE__) __attribute__((unavailable)); // expected-note{{explicitly made unavailable}}
 105 };
 106
 107 template<class C>
 108 void* object_creator() {
 109   return new C(); // expected-error{{call to unavailable function 'operator new[]'}}
 110 }
 111
 112 template void *object_creator<New3[4]>(); // expected-note{{instantiation}}
 113
 114 template<typename T>
 115 struct Delete0 {
 116   void f(T t) {
 117     delete t; // expected-error{{cannot delete}}
 118     ::delete [] t; // expected-error{{cannot delete}}
 119   }
 120 };
 121
 122 template struct Delete0<int*>;
 123 template struct Delete0<X*>;
 124 template struct Delete0<int>; // expected-note{{instantiation}}
 125
 126 namespace PR5755 {
 127   template <class T>
 128   void Foo() {
 129     char* p = 0;
 130     delete[] p;
 131   }
 132
 133   void Test() {
 134     Foo<int>();
 135   }
 136 }
 137
 138 namespace PR10480 {
 139   template<typename T>
 140   struct X {
 141     X();
 142     ~X() {
 143       T *ptr = 1; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
 144     }
 145   };
 146
 147   template<typename T>
 148   void f() {
 149     new X<int>[1]; // expected-note{{in instantiation of member function 'PR10480::X<int>::~X' requested here}}
 150   }
 151
 152   template void f<int>();
 153 }
 154
 155 // ---------------------------------------------------------------------
 156 // throw expressions
 157 // ---------------------------------------------------------------------
 158 template<typename T>
 159 struct Throw1 {
 160   void f(T t) {
 161     throw;
 162     throw t; // expected-error{{incomplete type}}
 163   }
 164 };
 165
 166 struct Incomplete; // expected-note 2{{forward}}
 167
 168 template struct Throw1<int>;
 169 template struct Throw1<int*>;
 170 template struct Throw1<Incomplete*>; // expected-note{{instantiation}}
 171
 172 // ---------------------------------------------------------------------
 173 // typeid expressions
 174 // ---------------------------------------------------------------------
 175
 176 namespace std {
 177   class type_info;
 178 }
 179
 180 template<typename T>
 181 struct TypeId0 {
 182   const std::type_info &f(T* ptr) {
 183     if (ptr)
 184       return typeid(ptr);
 185     else
 186       return typeid(T); // expected-error{{'typeid' of incomplete type 'Incomplete'}}
 187   }
 188 };
 189
 190 struct Abstract {
 191   virtual void f() = 0;
 192 };
 193
 194 template struct TypeId0<int>;
 195 template struct TypeId0<Incomplete>; // expected-note{{instantiation of member function}}
 196 template struct TypeId0<Abstract>;
 197
 198 // ---------------------------------------------------------------------
 199 // type traits
 200 // ---------------------------------------------------------------------
 201 template<typename T>
 202 struct is_pod {
 203   static const bool value = __is_pod(T);
 204 };
 205
 206 static int is_pod0[is_pod<X>::value? -1 : 1];
 207 static int is_pod1[is_pod<Y>::value? 1 : -1];
 208
 209 // ---------------------------------------------------------------------
 210 // initializer lists
 211 // ---------------------------------------------------------------------
 212 template<typename T, typename Val1>
 213 struct InitList1 {
 214   void f(Val1 val1) {
 215     T x = { val1 };
 216   }
 217 };
 218
 219 struct APair {
 220   int *x;
 221   const float *y;
 222 };
 223
 224 template struct InitList1<int[1], float>;
 225 template struct InitList1<APair, int*>;
 226
 227 template<typename T, typename Val1, typename Val2>
 228 struct InitList2 {
 229   void f(Val1 val1, Val2 val2) {
 230     T x = { val1, val2 }; // expected-error{{cannot initialize}}
 231   }
 232 };
 233
 234 template struct InitList2<APair, int*, float*>;
 235 template struct InitList2<APair, int*, double*>; // expected-note{{instantiation}}
 236
 237 // ---------------------------------------------------------------------
 238 // member references
 239 // ---------------------------------------------------------------------
 240 template<typename T, typename Result>
 241 struct DotMemRef0 {
 242   void f(T t) {
 243     Result result = t.m; // expected-error{{non-const lvalue reference to type}}
 244   }
 245 };
 246
 247 struct MemInt {
 248   int m;
 249 };
 250
 251 struct InheritsMemInt : MemInt { };
 252
 253 struct MemIntFunc {
 254   static int m(int);
 255 };
 256
 257 template struct DotMemRef0<MemInt, int&>;
 258 template struct DotMemRef0<InheritsMemInt, int&>;
 259 template struct DotMemRef0<MemIntFunc, int (*)(int)>;
 260 template struct DotMemRef0<MemInt, float&>; // expected-note{{instantiation}}
 261
 262 template<typename T, typename Result>
 263 struct ArrowMemRef0 {
 264   void f(T t) {
 265     Result result = t->m; // expected-error 2{{non-const lvalue reference}}
 266   }
 267 };
 268
 269 template<typename T>
 270 struct ArrowWrapper {
 271   T operator->();
 272 };
 273
 274 template struct ArrowMemRef0<MemInt*, int&>;
 275 template struct ArrowMemRef0<InheritsMemInt*, int&>;
 276 template struct ArrowMemRef0<MemIntFunc*, int (*)(int)>;
 277 template struct ArrowMemRef0<MemInt*, float&>; // expected-note{{instantiation}}
 278
 279 template struct ArrowMemRef0<ArrowWrapper<MemInt*>, int&>;
 280 template struct ArrowMemRef0<ArrowWrapper<InheritsMemInt*>, int&>;
 281 template struct ArrowMemRef0<ArrowWrapper<MemIntFunc*>, int (*)(int)>;
 282 template struct ArrowMemRef0<ArrowWrapper<MemInt*>, float&>; // expected-note{{instantiation}}
 283 template struct ArrowMemRef0<ArrowWrapper<ArrowWrapper<MemInt*> >, int&>;
 284
 285 struct UnresolvedMemRefArray {
 286   int f(int);
 287   int f(char);
 288 };
 289 UnresolvedMemRefArray Arr[10];
 290 template<typename U> int UnresolvedMemRefArrayT(U u) {
 291   return Arr->f(u);
 292 }
 293 template int UnresolvedMemRefArrayT<int>(int);
 294
 295 // FIXME: we should be able to return a MemInt without the reference!
 296 MemInt &createMemInt(int);
 297
 298 template<int N>
 299 struct NonDepMemberExpr0 {
 300   void f() {
 301     createMemInt(N).m = N;
 302   }
 303 };
 304
 305 template struct NonDepMemberExpr0<0>;
 306
 307 template<typename T, typename Result>
 308 struct MemberFuncCall0 {
 309   void f(T t) {
 310     Result result = t.f();
 311   }
 312 };
 313
 314 template<typename T>
 315 struct HasMemFunc0 {
 316   T f();
 317 };
 318
 319
 320 template struct MemberFuncCall0<HasMemFunc0<int&>, const int&>;
 321
 322 template<typename Result>
 323 struct ThisMemberFuncCall0 {
 324   Result g();
 325
 326   void f() {
 327     Result r1 = g();
 328     Result r2 = this->g();
 329   }
 330 };
 331
 332 template struct ThisMemberFuncCall0<int&>;
 333
 334 template<typename T>
 335 struct NonDepMemberCall0 {
 336   void foo(HasMemFunc0<int&> x) {
 337     T result = x.f(); // expected-error{{non-const lvalue reference}}
 338   }
 339 };
 340
 341 template struct NonDepMemberCall0<int&>;
 342 template struct NonDepMemberCall0<const int&>;
 343 template struct NonDepMemberCall0<float&>; // expected-note{{instantiation}}
 344
 345
 346 template<typename T>
 347 struct QualifiedDeclRef0 {
 348   T f() {
 349     return is_pod<X>::value; // expected-error{{non-const lvalue reference to type 'int' cannot bind to a value of unrelated type 'const bool'}}
 350   }
 351 };
 352
 353 template struct QualifiedDeclRef0<bool>;
 354 template struct QualifiedDeclRef0<int&>; // expected-note{{instantiation}}