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}} 355
