Home | History | Annotate | Download | only in SemaCXX
      1 // RUN: %clang_cc1 -Wreorder -fsyntax-only -verify %s
      2 class A {
      3   int m;
      4 public:
      5    A() : A::m(17) { } // expected-error {{member initializer 'm' does not name a non-static data member or base class}}
      6    A(int);
      7 };
      8 
      9 class B : public A {
     10 public:
     11   B() : A(), m(1), n(3.14) { }
     12 
     13 private:
     14   int m;
     15   float n;
     16 };
     17 
     18 
     19 class C : public virtual B {
     20 public:
     21   C() : B() { }
     22 };
     23 
     24 class D : public C {
     25 public:
     26   D() : B(), C() { }
     27 };
     28 
     29 class E : public D, public B {
     30 public:
     31   E() : B(), D() { } // expected-error{{base class initializer 'B' names both a direct base class and an inherited virtual base class}}
     32 };
     33 
     34 
     35 typedef int INT;
     36 
     37 class F : public B {
     38 public:
     39   int B;
     40 
     41   F() : B(17),
     42         m(17), // expected-error{{member initializer 'm' does not name a non-static data member or base class}}
     43         INT(17) // expected-error{{constructor initializer 'INT' (aka 'int') does not name a class}}
     44   {
     45   }
     46 };
     47 
     48 class G : A {
     49   G() : A(10); // expected-error{{expected '{'}}
     50 };
     51 
     52 void f() : a(242) { } // expected-error{{only constructors take base initializers}}
     53 
     54 class H : A {
     55   H();
     56 };
     57 
     58 H::H() : A(10) { }
     59 
     60 
     61 class  X {};
     62 class Y {};
     63 
     64 struct S : Y, virtual X {
     65   S ();
     66 };
     67 
     68 struct Z : S {
     69   Z() : X(), S(), E()  {} // expected-error {{type 'E' is not a direct or virtual base of 'Z'}}
     70 };
     71 
     72 class U {
     73   union { int a; char* p; };
     74   union { int b; double d; };
     75 
     76   U() :  a(1), // expected-note {{previous initialization is here}}
     77          p(0), // expected-error {{initializing multiple members of union}}
     78          d(1.0)  {}
     79 };
     80 
     81 struct V {};
     82 struct Base {};
     83 struct Base1 {};
     84 
     85 struct Derived : Base, Base1, virtual V {
     86   Derived ();
     87 };
     88 
     89 struct Current : Derived {
     90   int Derived;
     91   Current() : Derived(1), ::Derived(), // expected-warning {{field 'Derived' will be initialized after base '::Derived'}} \
     92                                        // expected-warning {{base class '::Derived' will be initialized after base 'Derived::V'}}
     93                           ::Derived::Base(), // expected-error {{type '::Derived::Base' is not a direct or virtual base of 'Current'}}
     94                            Derived::Base1(), // expected-error {{type 'Derived::Base1' is not a direct or virtual base of 'Current'}}
     95                            Derived::V(),
     96                            ::NonExisting(), // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}}
     97                            INT::NonExisting()  {} // expected-error {{'INT' (aka 'int') is not a class, namespace, or scoped enumeration}} \
     98                                                   // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}}
     99 };
    100 
    101 struct M {              // expected-note 2 {{candidate constructor (the implicit copy constructor)}} \
    102                         // expected-note {{declared here}} \
    103                         // expected-note {{declared here}}
    104   M(int i, int j);      // expected-note 2 {{candidate constructor}}
    105 };
    106 
    107 struct N : M  {
    108   N() : M(1),        // expected-error {{no matching constructor for initialization of 'M'}}
    109         m1(100) {  } // expected-error {{no matching constructor for initialization of 'M'}}
    110   M m1;
    111 };
    112 
    113 struct P : M  {
    114   P()  {  } // expected-error {{constructor for 'P' must explicitly initialize the base class 'M' which does not have a default constructor}} \
    115             // expected-error {{member 'm'}}
    116   M m; // expected-note {{member is declared here}}
    117 };
    118 
    119 struct Q {
    120   Q() : f1(1,2),       // expected-error {{excess elements in scalar initializer}}
    121         pf(0.0)  { }   // expected-error {{cannot initialize a member subobject of type 'float *' with an rvalue of type 'double'}}
    122   float f1;
    123 
    124   float *pf;
    125 };
    126 
    127 // A silly class used to demonstrate field-is-uninitialized in constructors with
    128 // multiple params.
    129 int IntParam(int i) { return 0; };
    130 class TwoInOne { public: TwoInOne(TwoInOne a, TwoInOne b) {} };
    131 class InitializeUsingSelfTest {
    132   bool A;
    133   char* B;
    134   int C;
    135   TwoInOne D;
    136   int E;
    137   InitializeUsingSelfTest(int F)
    138       : A(A),  // expected-warning {{field 'A' is uninitialized when used here}}
    139         B((((B)))),  // expected-warning {{field 'B' is uninitialized when used here}}
    140         C(A && InitializeUsingSelfTest::C),  // expected-warning {{field 'C' is uninitialized when used here}}
    141         D(D,  // expected-warning {{field 'D' is uninitialized when used here}}
    142           D), // expected-warning {{field 'D' is uninitialized when used here}}
    143         E(IntParam(E)) {} // expected-warning {{field 'E' is uninitialized when used here}}
    144 };
    145 
    146 int IntWrapper(int &i) { return 0; };
    147 class InitializeUsingSelfExceptions {
    148   int A;
    149   int B;
    150   int C;
    151   void *P;
    152   InitializeUsingSelfExceptions(int B)
    153       : A(IntWrapper(A)),  // Due to a conservative implementation, we do not report warnings inside function/ctor calls even though it is possible to do so.
    154         B(B),  // Not a warning; B is a local variable.
    155         C(sizeof(C)),  // sizeof doesn't reference contents, do not warn
    156         P(&P) {} // address-of doesn't reference contents (the pointer may be dereferenced in the same expression but it would be rare; and weird)
    157 };
    158 
    159 class CopyConstructorTest {
    160   bool A, B, C;
    161   CopyConstructorTest(const CopyConstructorTest& rhs)
    162       : A(rhs.A),
    163         B(B),  // expected-warning {{field 'B' is uninitialized when used here}}
    164         C(rhs.C || C) { }  // expected-warning {{field 'C' is uninitialized when used here}}
    165 };
    166 
    167 // Make sure we aren't marking default constructors when we shouldn't be.
    168 template<typename T>
    169 struct NDC {
    170   T &ref;
    171 
    172   NDC() { }
    173   NDC(T &ref) : ref(ref) { }
    174 };
    175 
    176 struct X0 : NDC<int> {
    177   X0(int &ref) : NDC<int>(ref), ndc(ref) { }
    178 
    179   NDC<int> ndc;
    180 };
    181 
    182 namespace Test0 {
    183 
    184 struct A { A(); };
    185 
    186 struct B {
    187   B() { }
    188   const A a;
    189 };
    190 
    191 }
    192 
    193 namespace Test1 {
    194   struct A {
    195     enum Kind { Foo } Kind;
    196     A() : Kind(Foo) {}
    197   };
    198 }
    199 
    200 namespace Test2 {
    201 
    202 struct A {
    203   A(const A&);
    204 };
    205 
    206 struct B : virtual A { };
    207 struct C : A, B { };
    208 
    209 C f(C c) {
    210   return c;
    211 }
    212 
    213 }
    214 
    215 // Don't build implicit initializers for anonymous union fields when we already
    216 // have an explicit initializer for another field in the union.
    217 namespace PR7402 {
    218   struct S {
    219     union {
    220       void* ptr_;
    221       struct { int i_; };
    222     };
    223 
    224     template <typename T> S(T) : ptr_(0) { }
    225   };
    226 
    227   void f() {
    228     S s(3);
    229   }
    230 }
    231 
    232 // <rdar://problem/8308215>: don't crash.
    233 // Lots of questionable recovery here;  errors can change.
    234 namespace test3 {
    235   class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}} expected-note 2 {{candidate}}
    236   class B : public A {
    237   public:
    238     B(const String& s, int e=0) // expected-error {{unknown type name}}
    239       : A(e), m_String(s) , m_ErrorStr(__null) {} // expected-error {{no matching constructor}} expected-error {{does not name}}
    240     B(const B& e)
    241       : A(e), m_String(e.m_String), m_ErrorStr(__null) { // expected-error {{does not name}} \
    242       // expected-error {{no member named 'm_String' in 'test3::B'}}
    243     }
    244   };
    245 }
    246 
    247 // PR8075
    248 namespace PR8075 {
    249 
    250 struct S1 {
    251   enum { FOO = 42 };
    252   static const int bar = 42;
    253   static int baz();
    254   S1(int);
    255 };
    256 
    257 const int S1::bar;
    258 
    259 struct S2 {
    260   S1 s1;
    261   S2() : s1(s1.FOO) {}
    262 };
    263 
    264 struct S3 {
    265   S1 s1;
    266   S3() : s1(s1.bar) {}
    267 };
    268 
    269 struct S4 {
    270   S1 s1;
    271   S4() : s1(s1.baz()) {}
    272 };
    273 
    274 }
    275 
    276 namespace PR12049 {
    277   int function();
    278 
    279   class Class
    280   {
    281   public:
    282       Class() : member(function() {} // expected-note {{to match this '('}}
    283 
    284       int member; // expected-error {{expected ')'}}
    285   };
    286 }
    287 
    288 namespace PR14073 {
    289   struct S1 { union { int n; }; S1() : n(n) {} };  // expected-warning {{field 'n' is uninitialized when used here}}
    290   struct S2 { union { union { int n; }; char c; }; S2() : n(n) {} };  // expected-warning {{field 'n' is uninitialized when used here}}
    291   struct S3 { struct { int n; }; S3() : n(n) {} };  // expected-warning {{field 'n' is uninitialized when used here}}
    292 }
    293