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 class TwoInOne { public: TwoInOne(TwoInOne a, TwoInOne b) {} }; 130 class 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 143 int IntWrapper(int i) { return 0; }; 144 class 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 156 class 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. 165 template<typename T> 166 struct NDC { 167 T &ref; 168 169 NDC() { } 170 NDC(T &ref) : ref(ref) { } 171 }; 172 173 struct X0 : NDC<int> { 174 X0(int &ref) : NDC<int>(ref), ndc(ref) { } 175 176 NDC<int> ndc; 177 }; 178 179 namespace Test0 { 180 181 struct A { A(); }; 182 183 struct B { 184 B() { } 185 const A a; 186 }; 187 188 } 189 190 namespace Test1 { 191 struct A { 192 enum Kind { Foo } Kind; 193 A() : Kind(Foo) {} 194 }; 195 } 196 197 namespace Test2 { 198 199 struct A { 200 A(const A&); 201 }; 202 203 struct B : virtual A { }; 204 struct C : A, B { }; 205 206 C 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. 214 namespace 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. 231 namespace 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 244 namespace PR8075 { 245 246 struct S1 { 247 enum { FOO = 42 }; 248 static const int bar = 42; 249 static int baz(); 250 S1(int); 251 }; 252 253 const int S1::bar; 254 255 struct S2 { 256 S1 s1; 257 S2() : s1(s1.FOO) {} 258 }; 259 260 struct S3 { 261 S1 s1; 262 S3() : s1(s1.bar) {} 263 }; 264 265 struct S4 { 266 S1 s1; 267 S4() : s1(s1.baz()) {} 268 }; 269 270 } 271 272 namespace PR12049 { 273 int function(); 274 275 class Class 276 { 277 public: 278 Class() : member(function() {} // expected-note {{to match this '('}} 279 280 int member; // expected-error {{expected ')'}} 281 }; 282 } 283