1 // RUN: %clang_cc1 -Wreorder -fsyntax-only -verify %s
2 class A {
3 int m;
4 public:
A()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:
B()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:
C()21 C() : B() { }
22 };
23
24 class D : public C {
25 public:
D()26 D() : B(), C() { }
27 };
28
29 class E : public D, public B { // expected-warning{{direct base 'B' is inaccessible due to ambiguity:\n class E -> class D -> class C -> class B\n class E -> class B}}
30 public:
E()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
F()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
f()52 void f() : a(242) { } // expected-error{{only constructors take base initializers}}
53
54 class H : A {
55 H();
56 };
57
H()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 {
ZZ69 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
U()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;
CurrentCurrent91 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 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 {
NN108 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 {
PP114 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 {
QQ120 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.
IntParam(int i)129 int IntParam(int i) { return 0; };
TwoInOne(TwoInOne a,TwoInOne b)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;
InitializeUsingSelfTest(int F)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
IntWrapper(int & i)146 int IntWrapper(int &i) { return 0; };
147 class InitializeUsingSelfExceptions {
148 int A;
149 int B;
150 int C;
151 void *P;
InitializeUsingSelfExceptions(int B)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;
CopyConstructorTest(const CopyConstructorTest & rhs)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
NDCNDC172 NDC() { }
NDCNDC173 NDC(T &ref) : ref(ref) { }
174 };
175
176 struct X0 : NDC<int> {
X0X0177 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 {
BTest0::B187 B() { }
188 const A a;
189 };
190
191 }
192
193 namespace Test1 {
194 struct A {
195 enum Kind { Foo } Kind;
ATest1::A196 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
208 struct C : A, B { }; // expected-warning{{direct base 'Test2::A' is inaccessible due to ambiguity:\n struct Test2::C -> struct Test2::A\n struct Test2::C -> struct Test2::B -> struct Test2::A}}
209
f(C c)210 C f(C c) {
211 return c;
212 }
213
214 }
215
216 // Don't build implicit initializers for anonymous union fields when we already
217 // have an explicit initializer for another field in the union.
218 namespace PR7402 {
219 struct S {
220 union {
221 void* ptr_;
222 struct { int i_; };
223 };
224
SPR7402::S225 template <typename T> S(T) : ptr_(0) { }
226 };
227
f()228 void f() {
229 S s(3);
230 }
231 }
232
233 // <rdar://problem/8308215>: don't crash.
234 // Lots of questionable recovery here; errors can change.
235 namespace test3 {
236 class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}} expected-note 2 {{candidate}}
237 class B : public A {
238 public:
B(const String & s,int e=0)239 B(const String& s, int e=0) // expected-error {{unknown type name}}
240 : A(e), m_String(s) , m_ErrorStr(__null) {} // expected-error {{no matching constructor}} expected-error {{does not name}}
B(const B & e)241 B(const B& e)
242 : A(e), m_String(e.m_String), m_ErrorStr(__null) { // expected-error {{does not name}} \
243 // expected-error {{no member named 'm_String' in 'test3::B'}}
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;
S2PR8075::S2262 S2() : s1(s1.FOO) {}
263 };
264
265 struct S3 {
266 S1 s1;
S3PR8075::S3267 S3() : s1(s1.bar) {}
268 };
269
270 struct S4 {
271 S1 s1;
S4PR8075::S4272 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