Home | History | Annotate | Download | only in SemaCXX
      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