1 // RUN: %clang_analyze_cc1 -analyzer-checker=core,optin.cplusplus.UninitializedObject \
2 // RUN: -analyzer-config optin.cplusplus.UninitializedObject:Pedantic=true -DPEDANTIC \
3 // RUN: -analyzer-config optin.cplusplus.UninitializedObject:CheckPointeeInitialization=true \
4 // RUN: -std=c++11 -verify %s
5
6 //===----------------------------------------------------------------------===//
7 // Non-polymorphic inheritance tests
8 //===----------------------------------------------------------------------===//
9
10 class NonPolymorphicLeft1 {
11 int x;
12
13 protected:
14 int y;
15
16 public:
17 NonPolymorphicLeft1() = default;
NonPolymorphicLeft1(int)18 NonPolymorphicLeft1(int) : x(1) {}
19 };
20
21 class NonPolymorphicInheritanceTest1 : public NonPolymorphicLeft1 {
22 int z;
23
24 public:
NonPolymorphicInheritanceTest1()25 NonPolymorphicInheritanceTest1()
26 : NonPolymorphicLeft1(int{}) {
27 y = 2;
28 z = 3;
29 // All good!
30 }
31 };
32
fNonPolymorphicInheritanceTest1()33 void fNonPolymorphicInheritanceTest1() {
34 NonPolymorphicInheritanceTest1();
35 }
36
37 class NonPolymorphicBaseClass2 {
38 int x; // expected-note{{uninitialized field 'this->NonPolymorphicBaseClass2::x'}}
39 protected:
40 int y;
41
42 public:
43 NonPolymorphicBaseClass2() = default;
NonPolymorphicBaseClass2(int)44 NonPolymorphicBaseClass2(int) : x(4) {}
45 };
46
47 class NonPolymorphicInheritanceTest2 : public NonPolymorphicBaseClass2 {
48 int z;
49
50 public:
NonPolymorphicInheritanceTest2()51 NonPolymorphicInheritanceTest2() {
52 y = 5;
53 z = 6; // expected-warning{{1 uninitialized field}}
54 }
55 };
56
fNonPolymorphicInheritanceTest2()57 void fNonPolymorphicInheritanceTest2() {
58 NonPolymorphicInheritanceTest2();
59 }
60
61 class NonPolymorphicBaseClass3 {
62 int x;
63
64 protected:
65 int y; // expected-note{{uninitialized field 'this->NonPolymorphicBaseClass3::y'}}
66 public:
67 NonPolymorphicBaseClass3() = default;
NonPolymorphicBaseClass3(int)68 NonPolymorphicBaseClass3(int) : x(7) {}
69 };
70
71 class NonPolymorphicInheritanceTest3 : public NonPolymorphicBaseClass3 {
72 int z;
73
74 public:
NonPolymorphicInheritanceTest3()75 NonPolymorphicInheritanceTest3()
76 : NonPolymorphicBaseClass3(int{}) {
77 z = 8; // expected-warning{{1 uninitialized field}}
78 }
79 };
80
fNonPolymorphicInheritanceTest3()81 void fNonPolymorphicInheritanceTest3() {
82 NonPolymorphicInheritanceTest3();
83 }
84
85 class NonPolymorphicBaseClass4 {
86 int x;
87
88 protected:
89 int y;
90
91 public:
92 NonPolymorphicBaseClass4() = default;
NonPolymorphicBaseClass4(int)93 NonPolymorphicBaseClass4(int) : x(9) {}
94 };
95
96 class NonPolymorphicInheritanceTest4 : public NonPolymorphicBaseClass4 {
97 int z; // expected-note{{uninitialized field 'this->z'}}
98
99 public:
NonPolymorphicInheritanceTest4()100 NonPolymorphicInheritanceTest4()
101 : NonPolymorphicBaseClass4(int{}) {
102 y = 10; // expected-warning{{1 uninitialized field}}
103 }
104 };
105
fNonPolymorphicInheritanceTest4()106 void fNonPolymorphicInheritanceTest4() {
107 NonPolymorphicInheritanceTest4();
108 }
109
110 //===----------------------------------------------------------------------===//
111 // Polymorphic inheritance tests
112 //===----------------------------------------------------------------------===//
113
114 class PolymorphicLeft1 {
115 int x;
116
117 protected:
118 int y;
119
120 public:
121 virtual ~PolymorphicLeft1() = default;
122 PolymorphicLeft1() = default;
PolymorphicLeft1(int)123 PolymorphicLeft1(int) : x(11) {}
124 };
125
126 class PolymorphicInheritanceTest1 : public PolymorphicLeft1 {
127 int z;
128
129 public:
PolymorphicInheritanceTest1()130 PolymorphicInheritanceTest1()
131 : PolymorphicLeft1(int{}) {
132 y = 12;
133 z = 13;
134 // All good!
135 }
136 };
137
fPolymorphicInheritanceTest1()138 void fPolymorphicInheritanceTest1() {
139 PolymorphicInheritanceTest1();
140 }
141
142 class PolymorphicRight1 {
143 int x; // expected-note{{uninitialized field 'this->PolymorphicRight1::x'}}
144 protected:
145 int y;
146
147 public:
148 virtual ~PolymorphicRight1() = default;
149 PolymorphicRight1() = default;
PolymorphicRight1(int)150 PolymorphicRight1(int) : x(14) {}
151 };
152
153 class PolymorphicInheritanceTest2 : public PolymorphicRight1 {
154 int z;
155
156 public:
PolymorphicInheritanceTest2()157 PolymorphicInheritanceTest2() {
158 y = 15;
159 z = 16; // expected-warning{{1 uninitialized field}}
160 }
161 };
162
fPolymorphicInheritanceTest2()163 void fPolymorphicInheritanceTest2() {
164 PolymorphicInheritanceTest2();
165 }
166
167 class PolymorphicBaseClass3 {
168 int x;
169
170 protected:
171 int y; // expected-note{{uninitialized field 'this->PolymorphicBaseClass3::y'}}
172 public:
173 virtual ~PolymorphicBaseClass3() = default;
174 PolymorphicBaseClass3() = default;
PolymorphicBaseClass3(int)175 PolymorphicBaseClass3(int) : x(17) {}
176 };
177
178 class PolymorphicInheritanceTest3 : public PolymorphicBaseClass3 {
179 int z;
180
181 public:
PolymorphicInheritanceTest3()182 PolymorphicInheritanceTest3()
183 : PolymorphicBaseClass3(int{}) {
184 z = 18; // expected-warning{{1 uninitialized field}}
185 }
186 };
187
fPolymorphicInheritanceTest3()188 void fPolymorphicInheritanceTest3() {
189 PolymorphicInheritanceTest3();
190 }
191
192 class PolymorphicBaseClass4 {
193 int x;
194
195 protected:
196 int y;
197
198 public:
199 virtual ~PolymorphicBaseClass4() = default;
200 PolymorphicBaseClass4() = default;
PolymorphicBaseClass4(int)201 PolymorphicBaseClass4(int) : x(19) {}
202 };
203
204 class PolymorphicInheritanceTest4 : public PolymorphicBaseClass4 {
205 int z; // expected-note{{uninitialized field 'this->z'}}
206
207 public:
PolymorphicInheritanceTest4()208 PolymorphicInheritanceTest4()
209 : PolymorphicBaseClass4(int{}) {
210 y = 20; // expected-warning{{1 uninitialized field}}
211 }
212 };
213
fPolymorphicInheritanceTest4()214 void fPolymorphicInheritanceTest4() {
215 PolymorphicInheritanceTest4();
216 }
217
218 //===----------------------------------------------------------------------===//
219 // Virtual inheritance tests
220 //===----------------------------------------------------------------------===//
221
222 class VirtualPolymorphicLeft1 {
223 int x;
224
225 protected:
226 int y;
227
228 public:
229 virtual ~VirtualPolymorphicLeft1() = default;
230 VirtualPolymorphicLeft1() = default;
VirtualPolymorphicLeft1(int)231 VirtualPolymorphicLeft1(int) : x(21) {}
232 };
233
234 class VirtualInheritanceTest1 : virtual public VirtualPolymorphicLeft1 {
235 int z;
236
237 public:
VirtualInheritanceTest1()238 VirtualInheritanceTest1()
239 : VirtualPolymorphicLeft1(int()) {
240 y = 22;
241 z = 23;
242 // All good!
243 }
244 };
245
fVirtualInheritanceTest1()246 void fVirtualInheritanceTest1() {
247 VirtualInheritanceTest1();
248 }
249
250 class VirtualPolymorphicRight1 {
251 int x; // expected-note{{uninitialized field 'this->VirtualPolymorphicRight1::x'}}
252 protected:
253 int y;
254
255 public:
256 virtual ~VirtualPolymorphicRight1() = default;
257 VirtualPolymorphicRight1() = default;
VirtualPolymorphicRight1(int)258 VirtualPolymorphicRight1(int) : x(24) {}
259 };
260
261 class VirtualInheritanceTest2 : virtual public VirtualPolymorphicRight1 {
262 int z;
263
264 public:
VirtualInheritanceTest2()265 VirtualInheritanceTest2() {
266 y = 25;
267 z = 26; // expected-warning{{1 uninitialized field}}
268 }
269 };
270
fVirtualInheritanceTest2()271 void fVirtualInheritanceTest2() {
272 VirtualInheritanceTest2();
273 }
274
275 class VirtualPolymorphicBaseClass3 {
276 int x;
277
278 protected:
279 int y; // expected-note{{uninitialized field 'this->VirtualPolymorphicBaseClass3::y'}}
280 public:
281 virtual ~VirtualPolymorphicBaseClass3() = default;
282 VirtualPolymorphicBaseClass3() = default;
VirtualPolymorphicBaseClass3(int)283 VirtualPolymorphicBaseClass3(int) : x(27) {}
284 };
285
286 class VirtualInheritanceTest3 : virtual public VirtualPolymorphicBaseClass3 {
287 int z;
288
289 public:
VirtualInheritanceTest3()290 VirtualInheritanceTest3()
291 : VirtualPolymorphicBaseClass3(int{}) {
292 z = 28; // expected-warning{{1 uninitialized field}}
293 }
294 };
295
fVirtualInheritanceTest3()296 void fVirtualInheritanceTest3() {
297 VirtualInheritanceTest3();
298 }
299
300 //===----------------------------------------------------------------------===//
301 // Multiple inheritance tests
302 //===----------------------------------------------------------------------===//
303
304 /*
305 Left Right
306 \ /
307 \ /
308 \ /
309 MultipleInheritanceTest
310 */
311
312 struct Left1 {
313 int x;
314 Left1() = default;
Left1Left1315 Left1(int) : x(29) {}
316 };
317 struct Right1 {
318 int y;
319 Right1() = default;
Right1Right1320 Right1(int) : y(30) {}
321 };
322
323 class MultipleInheritanceTest1 : public Left1, public Right1 {
324 int z;
325
326 public:
MultipleInheritanceTest1()327 MultipleInheritanceTest1()
328 : Left1(int{}),
329 Right1(char{}) {
330 z = 31;
331 // All good!
332 }
333
MultipleInheritanceTest1(int)334 MultipleInheritanceTest1(int)
335 : Left1(int{}) {
336 y = 32;
337 z = 33;
338 // All good!
339 }
340
MultipleInheritanceTest1(int,int)341 MultipleInheritanceTest1(int, int)
342 : Right1(char{}) {
343 x = 34;
344 z = 35;
345 // All good!
346 }
347 };
348
fMultipleInheritanceTest1()349 void fMultipleInheritanceTest1() {
350 MultipleInheritanceTest1();
351 MultipleInheritanceTest1(int());
352 MultipleInheritanceTest1(int(), int());
353 }
354
355 struct Left2 {
356 int x;
357 Left2() = default;
Left2Left2358 Left2(int) : x(36) {}
359 };
360 struct Right2 {
361 int y; // expected-note{{uninitialized field 'this->Right2::y'}}
362 Right2() = default;
Right2Right2363 Right2(int) : y(37) {}
364 };
365
366 class MultipleInheritanceTest2 : public Left2, public Right2 {
367 int z;
368
369 public:
MultipleInheritanceTest2()370 MultipleInheritanceTest2()
371 : Left2(int{}) {
372 z = 38; // expected-warning{{1 uninitialized field}}
373 }
374 };
375
fMultipleInheritanceTest2()376 void fMultipleInheritanceTest2() {
377 MultipleInheritanceTest2();
378 }
379
380 struct Left3 {
381 int x; // expected-note{{uninitialized field 'this->Left3::x'}}
382 Left3() = default;
Left3Left3383 Left3(int) : x(39) {}
384 };
385 struct Right3 {
386 int y;
387 Right3() = default;
Right3Right3388 Right3(int) : y(40) {}
389 };
390
391 class MultipleInheritanceTest3 : public Left3, public Right3 {
392 int z;
393
394 public:
MultipleInheritanceTest3()395 MultipleInheritanceTest3()
396 : Right3(char{}) {
397 z = 41; // expected-warning{{1 uninitialized field}}
398 }
399 };
400
fMultipleInheritanceTest3()401 void fMultipleInheritanceTest3() {
402 MultipleInheritanceTest3();
403 }
404
405 struct Left4 {
406 int x;
407 Left4() = default;
Left4Left4408 Left4(int) : x(42) {}
409 };
410 struct Right4 {
411 int y;
412 Right4() = default;
Right4Right4413 Right4(int) : y(43) {}
414 };
415
416 class MultipleInheritanceTest4 : public Left4, public Right4 {
417 int z; // expected-note{{uninitialized field 'this->z'}}
418
419 public:
MultipleInheritanceTest4()420 MultipleInheritanceTest4()
421 : Left4(int{}),
422 Right4(char{}) { // expected-warning{{1 uninitialized field}}
423 }
424 };
425
fMultipleInheritanceTest4()426 void fMultipleInheritanceTest4() {
427 MultipleInheritanceTest4();
428 }
429
430 struct Left5 {
431 int x;
432 Left5() = default;
Left5Left5433 Left5(int) : x(44) {}
434 };
435 struct Right5 {
436 int y; // expected-note{{uninitialized field 'this->Right5::y'}}
437 Right5() = default;
Right5Right5438 Right5(int) : y(45) {}
439 };
440
441 class MultipleInheritanceTest5 : public Left5, public Right5 {
442 int z; // expected-note{{uninitialized field 'this->z'}}
443
444 public:
MultipleInheritanceTest5()445 MultipleInheritanceTest5() // expected-warning{{2 uninitialized fields}}
446 : Left5(int{}) {
447 }
448 };
449
fMultipleInheritanceTest5()450 void fMultipleInheritanceTest5() {
451 MultipleInheritanceTest5();
452 }
453
454 //===----------------------------------------------------------------------===//
455 // Non-virtual diamond inheritance tests
456 //===----------------------------------------------------------------------===//
457
458 /*
459 NonVirtualBase NonVirtualBase
460 | |
461 | |
462 | |
463 First Second
464 \ /
465 \ /
466 \ /
467 NonVirtualDiamondInheritanceTest
468 */
469
470 struct NonVirtualBase1 {
471 int x;
472 NonVirtualBase1() = default;
NonVirtualBase1NonVirtualBase1473 NonVirtualBase1(int) : x(46) {}
474 };
475 struct First1 : public NonVirtualBase1 {
476 First1() = default;
First1First1477 First1(int) : NonVirtualBase1(int{}) {}
478 };
479 struct Second1 : public NonVirtualBase1 {
480 Second1() = default;
Second1Second1481 Second1(int) : NonVirtualBase1(int{}) {}
482 };
483
484 class NonVirtualDiamondInheritanceTest1 : public First1, public Second1 {
485 int z;
486
487 public:
NonVirtualDiamondInheritanceTest1()488 NonVirtualDiamondInheritanceTest1()
489 : First1(int{}),
490 Second1(int{}) {
491 z = 47;
492 // All good!
493 }
494
NonVirtualDiamondInheritanceTest1(int)495 NonVirtualDiamondInheritanceTest1(int)
496 : First1(int{}) {
497 Second1::x = 48;
498 z = 49;
499 // All good!
500 }
501
NonVirtualDiamondInheritanceTest1(int,int)502 NonVirtualDiamondInheritanceTest1(int, int)
503 : Second1(int{}) {
504 First1::x = 50;
505 z = 51;
506 // All good!
507 }
508 };
509
fNonVirtualDiamondInheritanceTest1()510 void fNonVirtualDiamondInheritanceTest1() {
511 NonVirtualDiamondInheritanceTest1();
512 NonVirtualDiamondInheritanceTest1(int());
513 NonVirtualDiamondInheritanceTest1(int(), int());
514 }
515
516 struct NonVirtualBase2 {
517 int x; // expected-note{{uninitialized field 'this->NonVirtualBase2::x'}}
518 NonVirtualBase2() = default;
NonVirtualBase2NonVirtualBase2519 NonVirtualBase2(int) : x(52) {}
520 };
521 struct First2 : public NonVirtualBase2 {
522 First2() = default;
First2First2523 First2(int) : NonVirtualBase2(int{}) {}
524 };
525 struct Second2 : public NonVirtualBase2 {
526 Second2() = default;
Second2Second2527 Second2(int) : NonVirtualBase2(int{}) {}
528 };
529
530 class NonVirtualDiamondInheritanceTest2 : public First2, public Second2 {
531 int z;
532
533 public:
NonVirtualDiamondInheritanceTest2()534 NonVirtualDiamondInheritanceTest2()
535 : First2(int{}) {
536 z = 53; // expected-warning{{1 uninitialized field}}
537 }
538 };
539
fNonVirtualDiamondInheritanceTest2()540 void fNonVirtualDiamondInheritanceTest2() {
541 NonVirtualDiamondInheritanceTest2();
542 }
543
544 struct NonVirtualBase3 {
545 int x; // expected-note{{uninitialized field 'this->NonVirtualBase3::x'}}
546 NonVirtualBase3() = default;
NonVirtualBase3NonVirtualBase3547 NonVirtualBase3(int) : x(54) {}
548 };
549 struct First3 : public NonVirtualBase3 {
550 First3() = default;
First3First3551 First3(int) : NonVirtualBase3(int{}) {}
552 };
553 struct Second3 : public NonVirtualBase3 {
554 Second3() = default;
Second3Second3555 Second3(int) : NonVirtualBase3(int{}) {}
556 };
557
558 class NonVirtualDiamondInheritanceTest3 : public First3, public Second3 {
559 int z;
560
561 public:
NonVirtualDiamondInheritanceTest3()562 NonVirtualDiamondInheritanceTest3()
563 : Second3(int{}) {
564 z = 55; // expected-warning{{1 uninitialized field}}
565 }
566 };
567
fNonVirtualDiamondInheritanceTest3()568 void fNonVirtualDiamondInheritanceTest3() {
569 NonVirtualDiamondInheritanceTest3();
570 }
571
572 struct NonVirtualBase4 {
573 int x; // expected-note{{uninitialized field 'this->NonVirtualBase4::x'}}
574 // expected-note@-1{{uninitialized field 'this->NonVirtualBase4::x'}}
575 NonVirtualBase4() = default;
NonVirtualBase4NonVirtualBase4576 NonVirtualBase4(int) : x(56) {}
577 };
578 struct First4 : public NonVirtualBase4 {
579 First4() = default;
First4First4580 First4(int) : NonVirtualBase4(int{}) {}
581 };
582 struct Second4 : public NonVirtualBase4 {
583 Second4() = default;
Second4Second4584 Second4(int) : NonVirtualBase4(int{}) {}
585 };
586
587 class NonVirtualDiamondInheritanceTest4 : public First4, public Second4 {
588 int z;
589
590 public:
NonVirtualDiamondInheritanceTest4()591 NonVirtualDiamondInheritanceTest4() {
592 z = 57; // expected-warning{{2 uninitialized fields}}
593 }
594 };
595
fNonVirtualDiamondInheritanceTest4()596 void fNonVirtualDiamondInheritanceTest4() {
597 NonVirtualDiamondInheritanceTest4();
598 }
599
600 struct NonVirtualBase5 {
601 int x;
602 NonVirtualBase5() = default;
NonVirtualBase5NonVirtualBase5603 NonVirtualBase5(int) : x(58) {}
604 };
605 struct First5 : public NonVirtualBase5 {
606 First5() = default;
First5First5607 First5(int) : NonVirtualBase5(int{}) {}
608 };
609 struct Second5 : public NonVirtualBase5 {
610 Second5() = default;
Second5Second5611 Second5(int) : NonVirtualBase5(int{}) {}
612 };
613
614 class NonVirtualDiamondInheritanceTest5 : public First5, public Second5 {
615 int z; // expected-note{{uninitialized field 'this->z'}}
616
617 public:
NonVirtualDiamondInheritanceTest5()618 NonVirtualDiamondInheritanceTest5()
619 : First5(int{}),
620 Second5(int{}) { // expected-warning{{1 uninitialized field}}
621 }
622 };
623
fNonVirtualDiamondInheritanceTest5()624 void fNonVirtualDiamondInheritanceTest5() {
625 NonVirtualDiamondInheritanceTest5();
626 }
627
628 struct NonVirtualBase6 {
629 int x; // expected-note{{uninitialized field 'this->NonVirtualBase6::x'}}
630 NonVirtualBase6() = default;
NonVirtualBase6NonVirtualBase6631 NonVirtualBase6(int) : x(59) {}
632 };
633 struct First6 : public NonVirtualBase6 {
634 First6() = default;
First6First6635 First6(int) : NonVirtualBase6(int{}) {}
636 };
637 struct Second6 : public NonVirtualBase6 {
638 Second6() = default;
Second6Second6639 Second6(int) : NonVirtualBase6(int{}) {}
640 };
641
642 class NonVirtualDiamondInheritanceTest6 : public First6, public Second6 {
643 int z; // expected-note{{uninitialized field 'this->z'}}
644
645 public:
NonVirtualDiamondInheritanceTest6()646 NonVirtualDiamondInheritanceTest6() // expected-warning{{2 uninitialized fields}}
647 : First6(int{}) {
648 // 'z' and 'Second::x' unintialized
649 }
650 };
651
fNonVirtualDiamondInheritanceTest6()652 void fNonVirtualDiamondInheritanceTest6() {
653 NonVirtualDiamondInheritanceTest6();
654 }
655
656 //===----------------------------------------------------------------------===//
657 // Virtual diamond inheritance tests
658 //===----------------------------------------------------------------------===//
659
660 /*
661 VirtualBase
662 / \
663 / \
664 / \
665 VirtualFirst VirtualSecond
666 \ /
667 \ /
668 \ /
669 VirtualDiamondInheritanceTest
670 */
671
672 struct VirtualBase1 {
673 int x;
674 VirtualBase1() = default;
VirtualBase1VirtualBase1675 VirtualBase1(int) : x(60) {}
676 };
677 struct VirtualFirst1 : virtual public VirtualBase1 {
678 VirtualFirst1() = default;
VirtualFirst1VirtualFirst1679 VirtualFirst1(int) : VirtualBase1(int{}) {}
VirtualFirst1VirtualFirst1680 VirtualFirst1(int, int) { x = 61; }
681 };
682 struct VirtualSecond1 : virtual public VirtualBase1 {
683 VirtualSecond1() = default;
VirtualSecond1VirtualSecond1684 VirtualSecond1(int) : VirtualBase1(int{}) {}
VirtualSecond1VirtualSecond1685 VirtualSecond1(int, int) { x = 62; }
686 };
687
688 class VirtualDiamondInheritanceTest1 : public VirtualFirst1, public VirtualSecond1 {
689
690 public:
VirtualDiamondInheritanceTest1()691 VirtualDiamondInheritanceTest1() {
692 x = 0;
693 // All good!
694 }
695
VirtualDiamondInheritanceTest1(int)696 VirtualDiamondInheritanceTest1(int)
697 : VirtualFirst1(int{}, int{}),
698 VirtualSecond1(int{}, int{}) {
699 // All good!
700 }
701
VirtualDiamondInheritanceTest1(int,int)702 VirtualDiamondInheritanceTest1(int, int)
703 : VirtualFirst1(int{}, int{}) {
704 // All good!
705 }
706 };
707
fVirtualDiamondInheritanceTest1()708 void fVirtualDiamondInheritanceTest1() {
709 VirtualDiamondInheritanceTest1();
710 VirtualDiamondInheritanceTest1(int());
711 VirtualDiamondInheritanceTest1(int(), int());
712 }
713
714 struct VirtualBase2 {
715 int x; // expected-note{{uninitialized field 'this->VirtualBase2::x'}}
716 VirtualBase2() = default;
VirtualBase2VirtualBase2717 VirtualBase2(int) : x(63) {}
718 };
719 struct VirtualFirst2 : virtual public VirtualBase2 {
720 VirtualFirst2() = default;
VirtualFirst2VirtualFirst2721 VirtualFirst2(int) : VirtualBase2(int{}) {}
VirtualFirst2VirtualFirst2722 VirtualFirst2(int, int) { x = 64; }
723 };
724 struct VirtualSecond2 : virtual public VirtualBase2 {
725 VirtualSecond2() = default;
VirtualSecond2VirtualSecond2726 VirtualSecond2(int) : VirtualBase2(int{}) {}
VirtualSecond2VirtualSecond2727 VirtualSecond2(int, int) { x = 65; }
728 };
729
730 class VirtualDiamondInheritanceTest2 : public VirtualFirst2, public VirtualSecond2 {
731
732 public:
VirtualDiamondInheritanceTest2()733 VirtualDiamondInheritanceTest2() // expected-warning{{1 uninitialized field}}
734 : VirtualFirst2(int{}) {
735 // From the N4659 C++ Standard Working Draft:
736 //
737 // (15.6.2.7)
738 // [...] A 'mem-initializer' where the 'mem-initializer-id' denotes a
739 // virtual base class is ignored during execution of a constructor of any
740 // class that is not the most derived class.
741 //
742 // This means that Left1::x will not be initialized, because in both
743 // VirtualFirst::VirtualFirst(int) and VirtualSecond::VirtualSecond(int)
744 // the constructor delegation to Left1::Left1(int) will be
745 // ignored.
746 }
747 };
748
fVirtualDiamondInheritanceTest2()749 void fVirtualDiamondInheritanceTest2() {
750 VirtualDiamondInheritanceTest2();
751 }
752
753 struct VirtualBase3 {
754 int x; // expected-note{{uninitialized field 'this->VirtualBase3::x'}}
755 VirtualBase3() = default;
VirtualBase3VirtualBase3756 VirtualBase3(int) : x(66) {}
757 };
758 struct VirtualFirst3 : virtual public VirtualBase3 {
759 VirtualFirst3() = default;
VirtualFirst3VirtualFirst3760 VirtualFirst3(int) : VirtualBase3(int{}) {}
VirtualFirst3VirtualFirst3761 VirtualFirst3(int, int) { x = 67; }
762 };
763 struct VirtualSecond3 : virtual public VirtualBase3 {
764 VirtualSecond3() = default;
VirtualSecond3VirtualSecond3765 VirtualSecond3(int) : VirtualBase3(int{}) {}
VirtualSecond3VirtualSecond3766 VirtualSecond3(int, int) { x = 68; }
767 };
768
769 class VirtualDiamondInheritanceTest3 : public VirtualFirst3, public VirtualSecond3 {
770
771 public:
VirtualDiamondInheritanceTest3()772 VirtualDiamondInheritanceTest3() // expected-warning{{1 uninitialized field}}
773 : VirtualFirst3(int{}) {}
774 };
775
fVirtualDiamondInheritanceTest3()776 void fVirtualDiamondInheritanceTest3() {
777 VirtualDiamondInheritanceTest3();
778 }
779
780 //===----------------------------------------------------------------------===//
781 // Dynamic type test.
782 //===----------------------------------------------------------------------===//
783
784 struct DynTBase1 {};
785 struct DynTDerived1 : DynTBase1 {
786 int y; // expected-note{{uninitialized field 'static_cast<struct DynTDerived1 *>(this->bptr)->y'}}
787 };
788
789 struct DynamicTypeTest1 {
790 DynTBase1 *bptr;
791 int i = 0;
792
DynamicTypeTest1DynamicTypeTest1793 DynamicTypeTest1(DynTBase1 *bptr) : bptr(bptr) {} // expected-warning{{1 uninitialized field}}
794 };
795
fDynamicTypeTest1()796 void fDynamicTypeTest1() {
797 DynTDerived1 d;
798 DynamicTypeTest1 t(&d);
799 };
800
801 struct DynTBase2 {
802 int x; // expected-note{{uninitialized field 'static_cast<struct DynTDerived2 *>(this->bptr)->DynTBase2::x'}}
803 };
804 struct DynTDerived2 : DynTBase2 {
805 int y; // expected-note{{uninitialized field 'static_cast<struct DynTDerived2 *>(this->bptr)->y'}}
806 };
807
808 struct DynamicTypeTest2 {
809 DynTBase2 *bptr;
810 int i = 0;
811
DynamicTypeTest2DynamicTypeTest2812 DynamicTypeTest2(DynTBase2 *bptr) : bptr(bptr) {} // expected-warning{{2 uninitialized fields}}
813 };
814
fDynamicTypeTest2()815 void fDynamicTypeTest2() {
816 DynTDerived2 d;
817 DynamicTypeTest2 t(&d);
818 }
819
820 struct SymbolicSuperRegionBase {
SymbolicSuperRegionBaseSymbolicSuperRegionBase821 SymbolicSuperRegionBase() {}
822 };
823
824 struct SymbolicSuperRegionDerived : SymbolicSuperRegionBase {
825 SymbolicSuperRegionBase *bptr; // no-crash
SymbolicSuperRegionDerivedSymbolicSuperRegionDerived826 SymbolicSuperRegionDerived(SymbolicSuperRegionBase *bptr) : bptr(bptr) {}
827 };
828
829 SymbolicSuperRegionDerived *getSymbolicRegion();
830
fSymbolicSuperRegionTest()831 void fSymbolicSuperRegionTest() {
832 SymbolicSuperRegionDerived test(getSymbolicRegion());
833 }
834