1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s 2 // REQUIRES: LP64 3 4 // ------------ not interpreted as C-style cast ------------ 5 6 struct SimpleValueInit { 7 int i; 8 }; 9 10 struct InitViaConstructor { 11 InitViaConstructor(int i = 7); 12 }; 13 14 struct NoValueInit { // expected-note 2 {{candidate constructor (the implicit copy constructor)}} expected-note 2 {{candidate constructor (the implicit move constructor)}} 15 NoValueInit(int i, int j); // expected-note 2 {{candidate constructor}} 16 }; 17 18 void test_cxx_functional_value_init() { 19 (void)SimpleValueInit(); 20 (void)InitViaConstructor(); 21 (void)NoValueInit(); // expected-error{{no matching constructor for initialization}} 22 } 23 24 void test_cxx_function_cast_multi() { 25 (void)NoValueInit(0, 0); 26 (void)NoValueInit(0, 0, 0); // expected-error{{no matching constructor for initialization}} 27 (void)int(1, 2); // expected-error{{excess elements in scalar initializer}} 28 (void)int({}, 2); // expected-error{{excess elements in scalar initializer}} 29 } 30 31 32 // ------------------ everything else -------------------- 33 34 struct A {}; 35 36 // ----------- const_cast -------------- 37 38 typedef char c; 39 typedef c *cp; 40 typedef cp *cpp; 41 typedef cpp *cppp; 42 typedef cppp &cpppr; 43 typedef const cppp &cpppcr; 44 typedef const char cc; 45 typedef cc *ccp; 46 typedef volatile ccp ccvp; 47 typedef ccvp *ccvpp; 48 typedef const volatile ccvpp ccvpcvp; 49 typedef ccvpcvp *ccvpcvpp; 50 typedef int iar[100]; 51 typedef iar &iarr; 52 typedef int (*f)(int); 53 54 void t_cc() 55 { 56 ccvpcvpp var = 0; 57 // Cast away deep consts and volatiles. 58 char ***var2 = cppp(var); 59 char ***const &var3 = var2; 60 // Const reference to reference. 61 char ***&var4 = cpppr(var3); 62 // Drop reference. Intentionally without qualifier change. 63 char *** var5 = cppp(var4); 64 const int ar[100] = {0}; 65 // Array decay. Intentionally without qualifier change. 66 typedef int *intp; 67 int *pi = intp(ar); 68 f fp = 0; 69 // Don't misidentify fn** as a function pointer. 70 typedef f *fp_t; 71 f *fpp = fp_t(&fp); 72 int const A::* const A::*icapcap = 0; 73 typedef int A::* A::*iapap_t; 74 iapap_t iapap = iapap_t(icapcap); 75 } 76 77 // ----------- static_cast ------------- 78 79 struct B : public A {}; // Single public base. 80 struct C1 : public virtual B {}; // Single virtual base. 81 struct C2 : public virtual B {}; 82 struct D : public C1, public C2 {}; // Diamond 83 struct E : private A {}; // Single private base. 84 struct F : public C1 {}; // Single path to B with virtual. 85 struct G1 : public B {}; 86 struct G2 : public B {}; 87 struct H : public G1, public G2 {}; // Ambiguous path to B. 88 89 enum Enum { En1, En2 }; 90 enum Onom { On1, On2 }; 91 92 struct Co1 { operator int(); }; 93 struct Co2 { Co2(int); }; 94 struct Co3 { }; 95 struct Co4 { Co4(Co3); operator Co3(); }; 96 97 // Explicit implicits 98 void t_529_2() 99 { 100 int i = 1; 101 (void)float(i); 102 double d = 1.0; 103 (void)float(d); 104 (void)int(d); 105 (void)char(i); 106 typedef unsigned long ulong; 107 (void)ulong(i); 108 (void)int(En1); 109 (void)double(En1); 110 typedef int &intr; 111 (void)intr(i); 112 typedef const int &cintr; 113 (void)cintr(i); 114 115 int ar[1]; 116 typedef const int *cintp; 117 (void)cintp(ar); 118 typedef void (*pfvv)(); 119 (void)pfvv(t_529_2); 120 121 typedef void *voidp; 122 (void)voidp(0); 123 (void)voidp((int*)0); 124 typedef volatile const void *vcvoidp; 125 (void)vcvoidp((const int*)0); 126 typedef A *Ap; 127 (void)Ap((B*)0); 128 typedef A &Ar; 129 (void)Ar(*((B*)0)); 130 typedef const B *cBp; 131 (void)cBp((C1*)0); 132 typedef B &Br; 133 (void)Br(*((C1*)0)); 134 (void)Ap((D*)0); 135 typedef const A &cAr; 136 (void)cAr(*((D*)0)); 137 typedef int B::*Bmp; 138 (void)Bmp((int A::*)0); 139 typedef void (B::*Bmfp)(); 140 (void)Bmfp((void (A::*)())0); 141 (void)Ap((E*)0); // functional-style cast ignores access control 142 (void)voidp((const int*)0); // const_cast appended 143 144 (void)int(Co1()); 145 (void)Co2(1); 146 (void)Co3((Co4)(Co3())); 147 148 // Bad code below 149 //(void)(A*)((H*)0); // {{static_cast from 'struct H *' to 'struct A *' is not allowed}} 150 } 151 152 // Anything to void 153 void t_529_4() 154 { 155 void(1); 156 (void(t_529_4)); 157 } 158 159 // Static downcasts 160 void t_529_5_8() 161 { 162 typedef B *Bp; 163 (void)Bp((A*)0); 164 typedef B &Br; 165 (void)Br(*((A*)0)); 166 typedef const G1 *cG1p; 167 (void)cG1p((A*)0); 168 typedef const G1 &cG1r; 169 (void)cG1r(*((A*)0)); 170 (void)Bp((const A*)0); // const_cast appended 171 (void)Br(*((const A*)0)); // const_cast appended 172 typedef E *Ep; 173 (void)Ep((A*)0); // access control ignored 174 typedef E &Er; 175 (void)Er(*((A*)0)); // access control ignored 176 177 // Bad code below 178 179 typedef C1 *C1p; 180 (void)C1p((A*)0); // expected-error {{cannot cast 'A *' to 'C1p' (aka 'C1 *') via virtual base 'B'}} 181 typedef C1 &C1r; 182 (void)C1r(*((A*)0)); // expected-error {{cannot cast 'A' to 'C1r' (aka 'C1 &') via virtual base 'B'}} 183 typedef D *Dp; 184 (void)Dp((A*)0); // expected-error {{cannot cast 'A *' to 'Dp' (aka 'D *') via virtual base 'B'}} 185 typedef D &Dr; 186 (void)Dr(*((A*)0)); // expected-error {{cannot cast 'A' to 'Dr' (aka 'D &') via virtual base 'B'}} 187 typedef H *Hp; 188 (void)Hp((A*)0); // expected-error {{ambiguous cast from base 'A' to derived 'H':\n struct A -> struct B -> struct G1 -> struct H\n struct A -> struct B -> struct G2 -> struct H}} 189 typedef H &Hr; 190 (void)Hr(*((A*)0)); // expected-error {{ambiguous cast from base 'A' to derived 'H':\n struct A -> struct B -> struct G1 -> struct H\n struct A -> struct B -> struct G2 -> struct H}} 191 192 // TODO: Test DR427. This requires user-defined conversions, though. 193 } 194 195 // Enum conversions 196 void t_529_7() 197 { 198 (void)Enum(1); 199 (void)Enum(1.0); 200 (void)Onom(En1); 201 202 // Bad code below 203 204 (void)Enum((int*)0); // expected-error {{functional-style cast from 'int *' to 'Enum' is not allowed}} 205 } 206 207 // Void pointer to object pointer 208 void t_529_10() 209 { 210 typedef int *intp; 211 (void)intp((void*)0); 212 typedef const A *cAp; 213 (void)cAp((void*)0); 214 (void)intp((const void*)0); // const_cast appended 215 } 216 217 // Member pointer upcast. 218 void t_529_9() 219 { 220 typedef int A::*Amp; 221 (void)Amp((int B::*)0); 222 223 // Bad code below 224 (void)Amp((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'H' to pointer to member of base class 'A':}} 225 (void)Amp((int F::*)0); // expected-error {{conversion from pointer to member of class 'F' to pointer to member of class 'A' via virtual base 'B' is not allowed}} 226 } 227 228 // -------- reinterpret_cast ----------- 229 230 enum test { testval = 1 }; 231 struct structure { int m; }; 232 typedef void (*fnptr)(); 233 234 // Test conversion between pointer and integral types, as in p3 and p4. 235 void integral_conversion() 236 { 237 typedef void *voidp; 238 void *vp = voidp(testval); 239 long l = long(vp); 240 typedef float *floatp; 241 (void)floatp(l); 242 fnptr fnp = fnptr(l); 243 (void)char(fnp); // expected-error {{cast from pointer to smaller type 'char' loses information}} 244 (void)long(fnp); 245 } 246 247 void pointer_conversion() 248 { 249 int *p1 = 0; 250 typedef float *floatp; 251 float *p2 = floatp(p1); 252 typedef structure *structurep; 253 structure *p3 = structurep(p2); 254 typedef int **ppint; 255 typedef ppint *pppint; 256 ppint *deep = pppint(p3); 257 typedef fnptr fnptrp; 258 (void)fnptrp(deep); 259 } 260 261 void constness() 262 { 263 int ***const ipppc = 0; 264 typedef int const *icp_t; 265 int const *icp = icp_t(ipppc); 266 typedef int *intp; 267 (void)intp(icp); // const_cast appended 268 typedef int const *const ** intcpcpp; 269 intcpcpp icpcpp = intcpcpp(ipppc); // const_cast appended 270 int *ip = intp(icpcpp); 271 (void)icp_t(ip); 272 typedef int const *const *const *intcpcpcp; 273 (void)intcpcpcp(ipppc); 274 } 275 276 void fnptrs() 277 { 278 typedef int (*fnptr2)(int); 279 fnptr fp = 0; 280 (void)fnptr2(fp); 281 typedef void *voidp; 282 void *vp = voidp(fp); 283 (void)fnptr(vp); 284 } 285 286 void refs() 287 { 288 long l = 0; 289 typedef char &charr; 290 char &c = charr(l); 291 // Bad: from rvalue 292 typedef int &intr; 293 (void)intr(&c); // expected-error {{functional-style cast from rvalue to reference type 'intr' (aka 'int &')}} 294 } 295 296 void memptrs() 297 { 298 const int structure::*psi = 0; 299 typedef const float structure::*structurecfmp; 300 (void)structurecfmp(psi); 301 typedef int structure::*structureimp; 302 (void)structureimp(psi); // const_cast appended 303 304 void (structure::*psf)() = 0; 305 typedef int (structure::*structureimfp)(); 306 (void)structureimfp(psf); 307 308 typedef void (structure::*structurevmfp)(); 309 (void)structurevmfp(psi); // expected-error-re {{functional-style cast from 'const int structure::*' to 'structurevmfp' (aka 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}') is not allowed}} 310 (void)structureimp(psf); // expected-error-re {{functional-style cast from 'void (structure::*)(){{( __attribute__\(\(thiscall\)\))?}}' to 'structureimp' (aka 'int structure::*') is not allowed}} 311 } 312 313 // ---------------- misc ------------------ 314 315 void crash_on_invalid_1() 316 { 317 typedef itn Typo; // expected-error {{unknown type name 'itn'}} 318 (void)Typo(1); // used to crash 319 320 typedef int &int_ref; 321 (void)int_ref(); // expected-error {{reference to type 'int' requires an initializer}} 322 } 323
