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