clang/test/SemaCXX/static-cast.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 struct A {};
   3 struct B : public A {};             // Single public base.
   4 struct C1 : public virtual B {};    // Single virtual base.
   5 struct C2 : public virtual B {};
   6 struct D : public C1, public C2 {}; // Diamond
   7 struct E : private A {};            // Single private base. expected-note 3 {{declared private here}}
   8 struct F : public C1 {};            // Single path to B with virtual.
   9 struct G1 : public B {};
  10 struct G2 : public B {};
  11 struct H : public G1, public G2 {}; // Ambiguous path to B.
  12 struct I;                           // Incomplete.  expected-note {{'I' is incomplete}}
  13 struct J;                           // Incomplete.  expected-note {{'J' is incomplete}}
  14
  15 enum Enum { En1, En2 };
  16 enum Onom { On1, On2 };
  17
  18 struct Co1 { operator int(); };
  19 struct Co2 { Co2(int); };
  20 struct Co3 { };
  21 struct Co4 { Co4(Co3); operator Co3(); };
  22
  23 // Explicit implicits
  24 void t_529_2()
  25 {
  26   int i = 1;
  27   (void)static_cast<float>(i);
  28   double d = 1.0;
  29   (void)static_cast<float>(d);
  30   (void)static_cast<int>(d);
  31   (void)static_cast<char>(i);
  32   (void)static_cast<unsigned long>(i);
  33   (void)static_cast<int>(En1);
  34   (void)static_cast<double>(En1);
  35   (void)static_cast<int&>(i);
  36   (void)static_cast<const int&>(i);
  37
  38   int ar[1];
  39   (void)static_cast<const int*>(ar);
  40   (void)static_cast<void (*)()>(t_529_2);
  41
  42   (void)static_cast<void*>(0);
  43   (void)static_cast<void*>((int*)0);
  44   (void)static_cast<volatile const void*>((const int*)0);
  45   (void)static_cast<A*>((B*)0);
  46   (void)static_cast<A&>(*((B*)0)); // expected-warning {{binding dereferenced null pointer to reference has undefined behavior}}
  47   (void)static_cast<const B*>((C1*)0);
  48   (void)static_cast<B&>(*((C1*)0)); // expected-warning {{binding dereferenced null pointer to reference has undefined behavior}}
  49   (void)static_cast<A*>((D*)0);
  50   (void)static_cast<const A&>(*((D*)0)); // expected-warning {{binding dereferenced null pointer to reference has undefined behavior}}
  51   (void)static_cast<int B::*>((int A::*)0);
  52   (void)static_cast<void (B::*)()>((void (A::*)())0);
  53
  54   (void)static_cast<int>(Co1());
  55   (void)static_cast<Co2>(1);
  56   (void)static_cast<Co3>(static_cast<Co4>(Co3()));
  57
  58   // Bad code below
  59
  60   (void)static_cast<void*>((const int*)0); // expected-error {{static_cast from 'const int *' to 'void *' is not allowed}}
  61   (void)static_cast<A*>((E*)0); // expected-error {{cannot cast 'E' to its private base class 'A'}}
  62   (void)static_cast<A*>((H*)0); // expected-error {{ambiguous conversion}}
  63   (void)static_cast<int>((int*)0); // expected-error {{static_cast from 'int *' to 'int' is not allowed}}
  64   (void)static_cast<A**>((B**)0); // expected-error {{static_cast from 'B **' to 'A **' is not allowed}}
  65   (void)static_cast<char&>(i); // expected-error {{non-const lvalue reference to type 'char' cannot bind to a value of unrelated type 'int'}}
  66 }
  67
  68 // Anything to void
  69 void t_529_4()
  70 {
  71   static_cast<void>(1);
  72   static_cast<void>(t_529_4);
  73 }
  74
  75 // Static downcasts
  76 void t_529_5_8()
  77 {
  78   (void)static_cast<B*>((A*)0);
  79   (void)static_cast<B&>(*((A*)0));
  80   (void)static_cast<const G1*>((A*)0);
  81   (void)static_cast<const G1&>(*((A*)0));
  82
  83   // Bad code below
  84
  85   (void)static_cast<C1*>((A*)0); // expected-error {{cannot cast 'A *' to 'C1 *' via virtual base 'B'}}
  86   (void)static_cast<C1&>(*((A*)0)); // expected-error {{cannot cast 'A' to 'C1 &' via virtual base 'B'}}
  87   (void)static_cast<D*>((A*)0); // expected-error {{cannot cast 'A *' to 'D *' via virtual base 'B'}}
  88   (void)static_cast<D&>(*((A*)0)); // expected-error {{cannot cast 'A' to 'D &' via virtual base 'B'}}
  89   (void)static_cast<B*>((const A*)0); // expected-error {{static_cast from 'const A *' to 'B *' casts away qualifiers}}
  90   (void)static_cast<B&>(*((const A*)0)); // expected-error {{static_cast from 'const A' to 'B &' casts away qualifiers}}
  91   (void)static_cast<E*>((A*)0); // expected-error {{cannot cast private base class 'A' to 'E'}}
  92   (void)static_cast<E&>(*((A*)0)); // expected-error {{cannot cast private base class 'A' to 'E'}}
  93   (void)static_cast<H*>((A*)0); // expected-error {{ambiguous cast from base 'A' to derived 'H':\n    A -> B -> G1 -> struct H\n    struct A -> B -> G2 -> struct H}}
  94   (void)static_cast<H&>(*((A*)0)); // expected-error {{ambiguous cast from base 'A' to derived 'H':\n    A -> B -> G1 -> struct H\n    A -> B -> G2 -> struct H}}
  95   (void)static_cast<E*>((B*)0); // expected-error {{static_cast from 'B *' to 'E *', which are not related by inheritance, is not allowed}}
  96   (void)static_cast<E&>(*((B*)0)); // expected-error {{non-const lvalue reference to type 'E' cannot bind to a value of unrelated type 'B'}}
  97
  98
  99   (void)static_cast<E*>((J*)0); // expected-error {{static_cast from 'J *' to 'E *', which are not related by inheritance, is not allowed}}
 100   (void)static_cast<I*>((B*)0); // expected-error {{static_cast from 'B *' to 'I *', which are not related by inheritance, is not allowed}}
 101
 102   // TODO: Test inaccessible base in context where it's accessible, i.e.
 103   // member function and friend.
 104
 105   // TODO: Test DR427. This requires user-defined conversions, though.
 106 }
 107
 108 // Enum conversions
 109 void t_529_7()
 110 {
 111   (void)static_cast<Enum>(1);
 112   (void)static_cast<Enum>(1.0);
 113   (void)static_cast<Onom>(En1);
 114
 115   // Bad code below
 116
 117   (void)static_cast<Enum>((int*)0); // expected-error {{static_cast from 'int *' to 'Enum' is not allowed}}
 118 }
 119
 120 // Void pointer to object pointer
 121 void t_529_10()
 122 {
 123   (void)static_cast<int*>((void*)0);
 124   (void)static_cast<const A*>((void*)0);
 125
 126   // Bad code below
 127
 128   (void)static_cast<int*>((const void*)0); // expected-error {{static_cast from 'const void *' to 'int *' casts away qualifiers}}
 129   (void)static_cast<void (*)()>((void*)0); // expected-error {{static_cast from 'void *' to 'void (*)()' is not allowed}}
 130 }
 131
 132 // Member pointer upcast.
 133 void t_529_9()
 134 {
 135   (void)static_cast<int A::*>((int B::*)0);
 136
 137   // Bad code below
 138   (void)static_cast<int A::*>((int H::*)0); // expected-error {{ambiguous conversion from pointer to member of derived class 'H' to pointer to member of base class 'A':}}
 139   (void)static_cast<int A::*>((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}}
 140   (void)static_cast<int I::*>((int J::*)0); // expected-error {{static_cast from 'int J::*' to 'int I::*' is not allowed}}
 141 }
 142
 143 // PR 5261 - static_cast should instantiate template if possible
 144 namespace pr5261 {
 145   struct base {};
 146   template<typename E> struct derived : public base {};
 147   template<typename E> struct outer {
 148     base *pb;
 149     ~outer() { (void)static_cast<derived<E>*>(pb); }
 150   };
 151   outer<int> EntryList;
 152 }
 153
 154
 155 // Initialization by constructor
 156 struct X0;
 157
 158 struct X1 {
 159   X1();
 160   X1(X1&);
 161   X1(const X0&);
 162
 163   operator X0() const;
 164 };
 165
 166 struct X0 { };
 167
 168 void test_ctor_init() {
 169   (void)static_cast<X1>(X1());
 170 }
 171
 172 // Casting away constness
 173 struct X2 {
 174 };
 175
 176 struct X3 : X2 {
 177 };
 178
 179 struct X4 {
 180   typedef const X3 X3_typedef;
 181
 182   void f() const {
 183     (void)static_cast<X3_typedef*>(x2);
 184   }
 185
 186   const X2 *x2;
 187 };
 188
 189 // PR5897 - accept static_cast from const void* to const int (*)[1].
 190 void PR5897() { (void)static_cast<const int(*)[1]>((const void*)0); }
 191
 192 namespace PR6072 {
 193   struct A { };
 194   struct B : A { void f(int); void f(); };  // expected-note 2{{candidate function}}
 195   struct C : B { };
 196   struct D { };
 197
 198   void f() {
 199     (void)static_cast<void (A::*)()>(&B::f);
 200     (void)static_cast<void (B::*)()>(&B::f);
 201     (void)static_cast<void (C::*)()>(&B::f);
 202     (void)static_cast<void (D::*)()>(&B::f); // expected-error-re{{address of overloaded function 'f' cannot be static_cast to type 'void (PR6072::D::*)(){{( __attribute__\(\(thiscall\)\))?}}'}}
 203   }
 204 }