Improve tests

Author: higher-performance

clang/include/clang/Basic/AttrDocs.td

@@ -1640,6 +1640,8 @@ initializers exist):
     }, {
       .count = sizeof(buf) / sizeof(*buf),
       // warning: field 'element_size' is not explicitly initialized
+      // (Note that a missing initializer for 'flags' is not diagnosed, because
+      // the field is not marked as requiring explicit initialization.)
     });
   }
 

clang/test/Sema/uninit-variables.c

@@ -557,8 +557,27 @@ struct with_explicit_field {
   int y [[clang::requires_explicit_initialization]]; // #FIELD_Y
 };
 
+struct with_explicit_array {
+  [[clang::requires_explicit_initialization]] int arr[2]; // #FIELD_ARR
+};
+
+struct with_explicit_flex_array {
+  int x;
+  [[clang::requires_explicit_initialization]] int flex_arr[]; // #FIELD_FLEX_ARR
+};
+
 void aggregate() {
   struct with_explicit_field a; // expected-warning {{field in 'with_explicit_field' requires explicit initialization but is not explicitly initialized}} expected-note@#FIELD_Y {{'y' declared here}}
   struct with_explicit_field b = {1}; // expected-warning {{field 'y' requires explicit initialization but is not explicitly initialized}} expected-note@#FIELD_Y {{'y' declared here}}
   (void)(&a != &b);
+
+  struct with_explicit_field c = {1, 2};
+  struct with_explicit_field d = {.y = 3};
+  (void)(&c != &d);
+
+  struct with_explicit_array e = {{1}};  // OK -- part of array is still initialized
+  (void)e;
+
+  struct with_explicit_flex_array f = {2}; // expected-warning {{field 'flex_arr' requires explicit initialization but is not explicitly initialized}} expected-note@#FIELD_FLEX_ARR {{'flex_arr' declared here}}
+  (void)f;
 }

clang/test/SemaCXX/uninitialized.cpp

@@ -1473,6 +1473,30 @@ template<typename T> struct Outer {
 };
 Outer<int>::Inner outerinner;
 
+struct Polymorphic { virtual ~Polymorphic() { } };
+
+template<class... Bases>
+struct Inherit : Bases... { // #TYPE_INHERIT
+  int g1; // #FIELD_G1
+};
+
+template<class... Bases>
+struct InheritWithExplicit : Bases... { // #TYPE_INHERIT_WITH_EXPLICIT
+  int g2 [[clang::requires_explicit_initialization]]; // #FIELD_G2
+};
+
+struct Special {};
+
+template<>
+struct Inherit<Special> {
+  int g3 [[clang::requires_explicit_initialization]]; // #FIELD_G3
+};
+
+template<>
+struct InheritWithExplicit<Special> {
+  int g4; // #FIELD_G4
+};
+
 void aggregate() {
   struct NonAgg {
     NonAgg() { }
@@ -1490,7 +1514,7 @@ void aggregate() {
   };
 
   struct C {
-    [[clang::requires_explicit_initialization]] int c1 = 2; // #FIELD_C1
+    [[clang::requires_explicit_initialization]] int c1; // #FIELD_C1
     C() = default;  // Test pre-C++20 aggregates
   };
 
@@ -1573,4 +1597,16 @@ void aggregate() {
   // expected-note@#FIELD_D2 {{'d2' declared here}}
   E e;
   (void)e;
+
+  InheritWithExplicit<> agg;  // expected-warning {{field in 'InheritWithExplicit<>' requires explicit initialization but is not explicitly initialized}} expected-note@#FIELD_G2 {{'g2' declared here}}
+  (void)agg;
+
+  InheritWithExplicit<Polymorphic> polymorphic;  // expected-warning@#FIELD_G2 {{'requires_explicit_initialization' attribute is ignored in non-aggregate type 'InheritWithExplicit<Polymorphic>'}}
+  (void)polymorphic;
+
+  Inherit<Special> specialized_explicit;  // expected-warning {{field in 'Inherit<Special>' requires explicit initialization but is not explicitly initialized}} expected-note@#FIELD_G3 {{'g3' declared here}}
+  (void)specialized_explicit;
+
+  InheritWithExplicit<Special> specialized_implicit;  // no-warning
+  (void)specialized_implicit;
 }