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: 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: 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: 24 C() : B() { } 25 }; 26 27 class D : public C { 28 public: 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: 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 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 55 void f() : a(242) { } // expected-error{{only constructors take base initializers}} 56 57 class H : A { 58 H(); 59 }; 60 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 { 72 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 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; 94 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 { 113 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 { 119 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 { 125 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. 134 int IntParam(int i) { return 0; }; 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; 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 151 int IntWrapper(int &i) { return 0; }; 152 class InitializeUsingSelfExceptions { 153 int A; 154 int B; 155 int C; 156 void *P; 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; 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 177 NDC() { } 178 NDC(T &ref) : ref(ref) { } 179 }; 180 181 struct X0 : NDC<int> { 182 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 { 192 B() { } 193 const A a; 194 }; 195 196 } 197 198 namespace Test1 { 199 struct A { 200 enum Kind { Foo } Kind; 201 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 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 230 template <typename T> S(T) : ptr_(0) { } 231 }; 232 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: 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}} 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; 273 S2() : s1(s1.FOO) {} 274 }; 275 276 struct S3 { 277 S1 s1; 278 S3() : s1(s1.bar) {} 279 }; 280 281 struct S4 { 282 S1 s1; 283 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
