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