blob: 0bef0cd6be4c8fda9fe4c6ad7641cc36679e8b3f [file] [log] [blame]
// RUN: %clang_cc1 -fsyntax-only -verify -faccess-control %s
// ------------ not interpreted as C-style cast ------------
struct SimpleValueInit {
int i;
struct InitViaConstructor {
InitViaConstructor(int i = 7);
struct NoValueInit { // expected-note 2 {{candidate constructor (the implicit copy constructor)}}
NoValueInit(int i, int j); // expected-note 2 {{candidate constructor}}
void test_cxx_functional_value_init() {
(void)NoValueInit(); // expected-error{{no matching constructor for initialization}}
void test_cxx_function_cast_multi() {
(void)NoValueInit(0, 0);
(void)NoValueInit(0, 0, 0); // expected-error{{no matching constructor for initialization}}
(void)int(1, 2); // expected-error{{function-style cast to a builtin type can only take one argument}}
// ------------------ everything else --------------------
struct A {};
// ----------- const_cast --------------
typedef char c;
typedef c *cp;
typedef cp *cpp;
typedef cpp *cppp;
typedef cppp &cpppr;
typedef const cppp &cpppcr;
typedef const char cc;
typedef cc *ccp;
typedef volatile ccp ccvp;
typedef ccvp *ccvpp;
typedef const volatile ccvpp ccvpcvp;
typedef ccvpcvp *ccvpcvpp;
typedef int iar[100];
typedef iar &iarr;
typedef int (*f)(int);
void t_cc()
ccvpcvpp var = 0;
// Cast away deep consts and volatiles.
char ***var2 = cppp(var);
char ***const &var3 = var2;
// Const reference to reference.
char ***&var4 = cpppr(var3);
// Drop reference. Intentionally without qualifier change.
char *** var5 = cppp(var4);
const int ar[100] = {0};
// Array decay. Intentionally without qualifier change.
typedef int *intp;
int *pi = intp(ar);
f fp = 0;
// Don't misidentify fn** as a function pointer.
typedef f *fp_t;
f *fpp = fp_t(&fp);
int const A::* const A::*icapcap = 0;
typedef int A::* A::*iapap_t;
iapap_t iapap = iapap_t(icapcap);
// ----------- static_cast -------------
struct B : public A {}; // Single public base.
struct C1 : public virtual B {}; // Single virtual base.
struct C2 : public virtual B {};
struct D : public C1, public C2 {}; // Diamond
struct E : private A {}; // Single private base.
struct F : public C1 {}; // Single path to B with virtual.
struct G1 : public B {};
struct G2 : public B {};
struct H : public G1, public G2 {}; // Ambiguous path to B.
enum Enum { En1, En2 };
enum Onom { On1, On2 };
struct Co1 { operator int(); };
struct Co2 { Co2(int); };
struct Co3 { };
struct Co4 { Co4(Co3); operator Co3(); };
// Explicit implicits
void t_529_2()
int i = 1;
double d = 1.0;
typedef unsigned long ulong;
typedef int &intr;
typedef const int &cintr;
int ar[1];
typedef const int *cintp;
typedef void (*pfvv)();
typedef void *voidp;
typedef volatile const void *vcvoidp;
(void)vcvoidp((const int*)0);
typedef A *Ap;
typedef A &Ar;
typedef const B *cBp;
typedef B &Br;
typedef const A &cAr;
typedef int B::*Bmp;
(void)Bmp((int A::*)0);
typedef void (B::*Bmfp)();
(void)Bmfp((void (A::*)())0);
(void)Ap((E*)0); // functional-style cast ignores access control
(void)voidp((const int*)0); // const_cast appended
// Bad code below
//(void)(A*)((H*)0); // {{static_cast from 'struct H *' to 'struct A *' is not allowed}}
// Anything to void
void t_529_4()
// Static downcasts
void t_529_5_8()
typedef B *Bp;
typedef B &Br;
typedef const G1 *cG1p;
typedef const G1 &cG1r;
(void)Bp((const A*)0); // const_cast appended
(void)Br(*((const A*)0)); // const_cast appended
typedef E *Ep;
(void)Ep((A*)0); // access control ignored
typedef E &Er;
(void)Er(*((A*)0)); // access control ignored
// Bad code below
typedef C1 *C1p;
(void)C1p((A*)0); // expected-error {{cannot cast 'struct A *' to 'C1p' (aka 'struct C1 *') via virtual base 'struct B'}}
typedef C1 &C1r;
(void)C1r(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'C1r' (aka 'struct C1 &') via virtual base 'struct B'}}
typedef D *Dp;
(void)Dp((A*)0); // expected-error {{cannot cast 'struct A *' to 'Dp' (aka 'struct D *') via virtual base 'struct B'}}
typedef D &Dr;
(void)Dr(*((A*)0)); // expected-error {{cannot cast 'struct A' to 'Dr' (aka 'struct D &') via virtual base 'struct B'}}
typedef H *Hp;
(void)Hp((A*)0); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n struct A -> struct B -> struct G1 -> struct H\n struct A -> struct B -> struct G2 -> struct H}}
typedef H &Hr;
(void)Hr(*((A*)0)); // expected-error {{ambiguous cast from base 'struct A' to derived 'struct H':\n struct A -> struct B -> struct G1 -> struct H\n struct A -> struct B -> struct G2 -> struct H}}
// TODO: Test DR427. This requires user-defined conversions, though.
// Enum conversions
void t_529_7()
// Bad code below
(void)Enum((int*)0); // expected-error {{functional-style cast from 'int *' to 'enum Enum' is not allowed}}
// Void pointer to object pointer
void t_529_10()
typedef int *intp;
typedef const A *cAp;
(void)intp((const void*)0); // const_cast appended
// Member pointer upcast.
void t_529_9()
typedef int A::*Amp;
(void)Amp((int B::*)0);
// Bad code below
(void)Amp((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'struct H'}}
(void)Amp((int F::*)0); // expected-error {{conversion from pointer to member of class 'struct F'}}
// -------- reinterpret_cast -----------
enum test { testval = 1 };
struct structure { int m; };
typedef void (*fnptr)();
// Test conversion between pointer and integral types, as in p3 and p4.
void integral_conversion()
typedef void *voidp;
void *vp = voidp(testval);
long l = long(vp);
typedef float *floatp;
fnptr fnp = fnptr(l);
(void)char(fnp); // expected-error {{cast from pointer to smaller type 'char' loses information}}
void pointer_conversion()
int *p1 = 0;
typedef float *floatp;
float *p2 = floatp(p1);
typedef structure *structurep;
structure *p3 = structurep(p2);
typedef int **ppint;
typedef ppint *pppint;
ppint *deep = pppint(p3);
typedef fnptr fnptrp;
void constness()
int ***const ipppc = 0;
typedef int const *icp_t;
int const *icp = icp_t(ipppc);
typedef int *intp;
(void)intp(icp); // const_cast appended
typedef int const *const ** intcpcpp;
intcpcpp icpcpp = intcpcpp(ipppc); // const_cast appended
int *ip = intp(icpcpp);
typedef int const *const *const *intcpcpcp;
void fnptrs()
typedef int (*fnptr2)(int);
fnptr fp = 0;
typedef void *voidp;
void *vp = voidp(fp);
void refs()
long l = 0;
typedef char &charr;
char &c = charr(l);
// Bad: from rvalue
typedef int &intr;
(void)intr(&c); // expected-error {{functional-style cast from rvalue to reference type 'intr' (aka 'int &')}}
void memptrs()
const int structure::*psi = 0;
typedef const float structure::*structurecfmp;
typedef int structure::*structureimp;
(void)structureimp(psi); // const_cast appended
void (structure::*psf)() = 0;
typedef int (structure::*structureimfp)();
typedef void (structure::*structurevmfp)();
(void)structurevmfp(psi); // expected-error {{functional-style cast from 'int const struct structure::*' to 'structurevmfp' (aka 'void (struct structure::*)()') is not allowed}}
(void)structureimp(psf); // expected-error {{functional-style cast from 'void (struct structure::*)()' to 'structureimp' (aka 'int struct structure::*') is not allowed}}
// ---------------- misc ------------------
void crash_on_invalid_1()
typedef itn Typo; // expected-error {{unknown type name 'itn'}}
(void)Typo(1); // used to crash