[clang][Interp] Fix diagnosing uninitialized ctor record arrays

[tbaeder]

Summary

No idea why I used isa<RecordType>(ElemType.getTypePtr()) here, but it broke detecting that the element type is of record type.

Other than that, I think a previous patch made it possible to enable those two tests that have been disabled so far.

[tbaeder]

Ping

[aaron.ballman]

clang/lib/AST/Interp/Interp.cpp

389

The difference between these two is that isRecordType() is looking at the canonical type whereas isa<> is looking at the type under inspection rather than the canonical type. I'd expect these to have the same behavior in most cases, but only matter for cases involving typedefs.

I think you're correct about the test case below not needing these particular changes -- at least, I'm not seeing what's changed that should impact the test. Should this be split into two changes? 1) Expose the test, 2) Make this functional change + add a new test where the canonical type is different to demonstrate the fix.

[shafik]

clang/lib/AST/Interp/Interp.cpp

389

+1

[tbaeder]

clang/lib/AST/Interp/Interp.cpp

389

Can you come up with a small test case that would show the difference? You mentioned typedefs, but if the array is of a typedef type, the old isa<> version doesn't work either.

clang/test/AST/Interp/cxx20.cpp

182

This line actually needs the changes in this patch, the array is of record type.

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

LG with a request for an additional test.

clang/lib/AST/Interp/Interp.cpp

389

Ah, I see what you mean, yeah. With a typedef type, the isa would have also failed. That's a good test case to add to this patch as well.

clang/lib/AST/Interp/Interp.cpp

 
 static bool CheckArrayInitialized(InterpState &S, CodePtr OpPC,
                                   const Pointer &BasePtr,
                                   const ConstantArrayType *CAT) {
   bool Result = true;
   size_t NumElems = CAT->getSize().getZExtValue();
   QualType ElemType = CAT->getElementType();
 
-  if (isa<RecordType>(ElemType.getTypePtr())) {
+  if (ElemType->isRecordType()) {
     const Record *R = BasePtr.getElemRecord();
     for (size_t I = 0; I != NumElems; ++I) {
       Pointer ElemPtr = BasePtr.atIndex(I).narrow();
       Result &= CheckFieldsInitialized(S, OpPC, ElemPtr, R);
     }
   } else if (auto *ElemCAT = dyn_cast<ConstantArrayType>(ElemType)) {
     for (size_t I = 0; I != NumElems; ++I) {
       Pointer ElemPtr = BasePtr.atIndex(I).narrow();

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 2{{subobject declared here}} \
-           // ref-note 2{{subobject declared here}}
+    int a; // expected-note 3{{subobject declared here}} \
+           // ref-note 3{{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}}
 
 
namespace UninitializedFields {
   public:
     A a;
     constexpr C2() {}   };
   constexpr C2 c2; // 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}}
 
-
-  // FIXME: These two are currently disabled because the array fields
-  //   cannot be initialized.
-#if 0
   class C3 {
   public:
     A a[2];
     constexpr C3() {}
   };
   constexpr C3 c3; // expected-error {{must be initialized by a constant expression}} \
-                   // expected-note {{subobject of type 'int' is not initialized}} \
+                   // expected-note {{subobject 'a' is not initialized}} \
                    // ref-error {{must be initialized by a constant expression}} \
-                   // ref-note {{subobject of type 'int' is not initialized}}
+                   // ref-note {{subobject 'a' is not initialized}}
 
   class C4 {
   public:
     bool B[2][3]; // expected-note {{subobject declared here}} \
                   // ref-note {{subobject declared here}}
     constexpr C4(){}
   };
   constexpr C4 c4; // expected-error {{must be initialized by a constant expression}} \
-                   // expected-note {{subobject of type 'bool' is not initialized}} \
+                   // expected-note {{subobject 'B' is not initialized}} \
                    // ref-error {{must be initialized by a constant expression}} \
-                   // ref-note {{subobject of type 'bool' is not initialized}}
-#endif
+                   // ref-note {{subobject 'B' is not initialized}}
 };
 
 namespace ConstThis {
   class Foo {
     const int T = 12; // expected-note {{declared const here}} \
                       // ref-note {{declared const here}}
     int a;
   public: