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 {{expected a class or namespace}} \ 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 4 {{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 // expected-error {{no matching}} 244 } 245 }; 246 } 247 248 // PR8075 249 namespace PR8075 { 250 251 struct S1 { 252 enum { FOO = 42 }; 253 static const int bar = 42; 254 static int baz(); 255 S1(int); 256 }; 257 258 const int S1::bar; 259 260 struct S2 { 261 S1 s1; 262 S2() : s1(s1.FOO) {} 263 }; 264 265 struct S3 { 266 S1 s1; 267 S3() : s1(s1.bar) {} 268 }; 269 270 struct S4 { 271 S1 s1; 272 S4() : s1(s1.baz()) {} 273 }; 274 275 } 276 277 namespace PR12049 { 278 int function(); 279 280 class Class 281 { 282 public: 283 Class() : member(function() {} // expected-note {{to match this '('}} 284 285 int member; // expected-error {{expected ')'}} 286 }; 287 } 288 289 namespace PR14073 { 290 struct S1 { union { int n; }; S1() : n(n) {} }; // expected-warning {{field 'n' is uninitialized when used here}} 291 struct S2 { union { union { int n; }; char c; }; S2() : n(n) {} }; // expected-warning {{field 'n' is uninitialized when used here}} 292 struct S3 { struct { int n; }; S3() : n(n) {} }; // expected-warning {{field 'n' is uninitialized when used here}} 293 } 294