1// RUN: %clang_cc1 -Wreorder -fsyntax-only -verify %s 2class A { 3 int m; 4public: 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 9class B : public A { 10public: 11 B() : A(), m(1), n(3.14) { } 12 13private: 14 int m; 15 float n; 16}; 17 18 19class C : public virtual B { 20public: 21 C() : B() { } 22}; 23 24class D : public C { 25public: 26 D() : B(), C() { } 27}; 28 29class E : public D, public B { 30public: 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 35typedef int INT; 36 37class F : public B { 38public: 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 48class G : A { 49 G() : A(10); // expected-error{{expected '{'}} 50}; 51 52void f() : a(242) { } // expected-error{{only constructors take base initializers}} 53 54class H : A { 55 H(); 56}; 57 58H::H() : A(10) { } 59 60 61class X {}; 62class Y {}; 63 64struct S : Y, virtual X { 65 S (); 66}; 67 68struct Z : S { 69 Z() : X(), S(), E() {} // expected-error {{type 'E' is not a direct or virtual base of 'Z'}} 70}; 71 72class 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 anonymous union}} 78 d(1.0) {} 79}; 80 81struct V {}; 82struct Base {}; 83struct Base1 {}; 84 85struct Derived : Base, Base1, virtual V { 86 Derived (); 87}; 88 89struct 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 {{expected a class or namespace}} \ 98 // expected-error {{member initializer 'NonExisting' does not name a non-static data member or}} 99}; 100 101struct 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 107struct 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 113struct 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 119struct 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. 129class TwoInOne { public: TwoInOne(TwoInOne a, TwoInOne b) {} }; 130class InitializeUsingSelfTest { 131 bool A; 132 char* B; 133 int C; 134 TwoInOne D; 135 InitializeUsingSelfTest(int E) 136 : A(A), // expected-warning {{field is uninitialized when used here}} 137 B((((B)))), // expected-warning {{field is uninitialized when used here}} 138 C(A && InitializeUsingSelfTest::C), // expected-warning {{field is uninitialized when used here}} 139 D(D, // expected-warning {{field is uninitialized when used here}} 140 D) {} // expected-warning {{field is uninitialized when used here}} 141}; 142 143int IntWrapper(int i) { return 0; }; 144class InitializeUsingSelfExceptions { 145 int A; 146 int B; 147 int C; 148 void *P; 149 InitializeUsingSelfExceptions(int B) 150 : 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. 151 B(B), // Not a warning; B is a local variable. 152 C(sizeof(C)), // sizeof doesn't reference contents, do not warn 153 P(&P) {} // address-of doesn't reference contents (the pointer may be dereferenced in the same expression but it would be rare; and weird) 154}; 155 156class CopyConstructorTest { 157 bool A, B, C; 158 CopyConstructorTest(const CopyConstructorTest& rhs) 159 : A(rhs.A), 160 B(B), // expected-warning {{field is uninitialized when used here}} 161 C(rhs.C || C) { } // expected-warning {{field is uninitialized when used here}} 162}; 163 164// Make sure we aren't marking default constructors when we shouldn't be. 165template<typename T> 166struct NDC { 167 T &ref; 168 169 NDC() { } 170 NDC(T &ref) : ref(ref) { } 171}; 172 173struct X0 : NDC<int> { 174 X0(int &ref) : NDC<int>(ref), ndc(ref) { } 175 176 NDC<int> ndc; 177}; 178 179namespace Test0 { 180 181struct A { A(); }; 182 183struct B { 184 B() { } 185 const A a; 186}; 187 188} 189 190namespace Test1 { 191 struct A { 192 enum Kind { Foo } Kind; 193 A() : Kind(Foo) {} 194 }; 195} 196 197namespace Test2 { 198 199struct A { 200 A(const A&); 201}; 202 203struct B : virtual A { }; 204struct C : A, B { }; 205 206C f(C c) { 207 return c; 208} 209 210} 211 212// Don't build implicit initializers for anonymous union fields when we already 213// have an explicit initializer for another field in the union. 214namespace PR7402 { 215 struct S { 216 union { 217 void* ptr_; 218 struct { int i_; }; 219 }; 220 221 template <typename T> S(T) : ptr_(0) { } 222 }; 223 224 void f() { 225 S s(3); 226 } 227} 228 229// <rdar://problem/8308215>: don't crash. 230// Lots of questionable recovery here; errors can change. 231namespace test3 { 232 class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}} expected-note 3 {{candidate}} expected-note {{passing argument}} 233 class B : public A { 234 public: 235 B(const String& s, int e=0) // expected-error {{unknown type name}} 236 : A(e), m_String(s) , m_ErrorStr(__null) {} // expected-error {{no matching constructor}} expected-error {{does not name}} 237 B(const B& e) 238 : A(e), m_String(e.m_String), m_ErrorStr(__null) { // expected-error {{no viable conversion}} expected-error {{does not name}} 239 } 240 }; 241} 242 243// PR8075 244namespace PR8075 { 245 246struct S1 { 247 enum { FOO = 42 }; 248 static const int bar = 42; 249 static int baz(); 250 S1(int); 251}; 252 253const int S1::bar; 254 255struct S2 { 256 S1 s1; 257 S2() : s1(s1.FOO) {} 258}; 259 260struct S3 { 261 S1 s1; 262 S3() : s1(s1.bar) {} 263}; 264 265struct S4 { 266 S1 s1; 267 S4() : s1(s1.baz()) {} 268}; 269 270} 271