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