[Clang][Interp] Diagnose uninitialized ctor of global record arrays

[hazohelet]

Summary

This patch adds a check for uninitialized subobjects of global variables that are record arrays.
e.g. constexpr Foo f[2];

[tbaeder]

clang/test/AST/Interp/cxx20.cpp

177

We usually have a space after the ; and keep the comments aligned on the //.

[hazohelet]

Address comment from @tbaeder

• NFC stylistic change in test

[tbaeder]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.h

protected:
   /// Visits an initializer for a global.
   bool visitGlobalInitializer(const Expr *Init, unsigned I) {
     if (!this->emitGetPtrGlobal(I, Init))
       return false;
 
     if (!visitInitializer(Init))
       return false;
 
-    if (Init->getType()->isRecordType() && !this->emitCheckGlobalCtor(Init))
+    if ((Init->getType()->isArrayType() || Init->getType()->isRecordType()) &&
+        !this->emitCheckGlobalCtor(Init))
       return false;
 
     return this->emitPopPtr(Init);
   }
 
   /// Visits a delegated initializer.
   bool visitThisInitializer(const Expr *I) {
     if (!this->emitThis(I))

clang/lib/AST/Interp/Interp.cpp

static bool CheckFieldsInitialized(InterpState &S, CodePtr OpPC,
 
   // TODO: Virtual bases
 
   return Result;
 }
 
 bool CheckCtorCall(InterpState &S, CodePtr OpPC, const Pointer &This) {
   assert(!This.isZero());
-  const Record *R = This.getRecord();
+  if (const Record *R = This.getRecord())
     return CheckFieldsInitialized(S, OpPC, This, R);
+  const auto *CAT =
+      cast<ConstantArrayType>(This.getType()->getAsArrayTypeUnsafe());
+  return CheckArrayInitialized(S, OpPC, This, CAT);
 }
 
 bool CheckFloatResult(InterpState &S, CodePtr OpPC, APFloat::opStatus Status) {
   // In a constant context, assume that any dynamic rounding mode or FP
   // exception state matches the default floating-point environment.
   if (S.inConstantContext())
     return true;
 

clang/test/AST/Interp/cxx20.cpp

constexpr auto b4 = name1() == name2(); // ref-error {{must be initialized by a constant expression}} \
                                         // ref-note {{has unspecified value}} \
                                         // ref-note {{declared here}}
 static_assert(!b4); // ref-error {{not an integral constant expression}} \
                     // ref-note {{not a constant expression}}
 
 namespace UninitializedFields {
   class A {
   public:
-    int a; // expected-note 3{{subobject declared here}} \
-           // ref-note 3{{subobject declared here}}
+    int a; // expected-note 4{{subobject declared here}} \
+           // ref-note 4{{subobject declared here}}
     constexpr A() {}
   };
   constexpr A a; // expected-error {{must be initialized by a constant expression}} \
                  // expected-note {{subobject 'a' is not initialized}} \
                  // ref-error {{must be initialized by a constant expression}} \
                  // ref-note {{subobject 'a' is not initialized}}
+  constexpr A aarr[2]; // expected-error {{must be initialized by a constant expression}} \
+                       // expected-note {{subobject 'a' is not initialized}} \
+                       // ref-error {{must be initialized by a constant expression}} \
+                       // ref-note {{subobject 'a' is not initialized}}
+  class F {
+    public:
+      int f; // expected-note 3{{subobject declared here}} \
+             // ref-note 3{{subobject declared here}}
+
+      constexpr F() {}
+      constexpr F(bool b) {
+        if (b)
+          f = 42;
+      }
+  };
+
+  constexpr F foo[2] = {true}; // expected-error {{must be initialized by a constant expression}} \
+                               // expected-note {{subobject 'f' is not initialized}} \
+                               // ref-error {{must be initialized by a constant expression}} \
+                               // ref-note {{subobject 'f' is not initialized}}
+  constexpr F foo2[3] = {true, false, true}; // expected-error {{must be initialized by a constant expression}} \
+                                             // expected-note {{subobject 'f' is not initialized}} \
+                                             // ref-error {{must be initialized by a constant expression}} \
+                                             // ref-note {{subobject 'f' is not initialized}}
+  constexpr F foo3[3] = {true, true, F()}; // expected-error {{must be initialized by a constant expression}} \
+                                           // expected-note {{subobject 'f' is not initialized}} \
+                                           // ref-error {{must be initialized by a constant expression}} \
+                                           // ref-note {{subobject 'f' is not initialized}}
+
 
 
   class Base {
   public:
     bool b;
     int a; // expected-note {{subobject declared here}} \
            // ref-note {{subobject declared here}}
     constexpr Base() : b(true) {}