[clang][Interp] Fix initializing fields after base class members

[tbaeder]

Ping

[aaron.ballman]

LGTM with a bit more testing.

clang/test/AST/Interp/cxx20.cpp

600

clang/lib/AST/Interp/ByteCodeExprGen.cpp

for (const Expr *Init : InitList->inits()) {
         if (!this->visit(Init))
           return false;
 
         if (!this->emitInitField(*T, FieldToInit->Offset, Initializer))
           return false;
 
         if (!this->emitPopPtr(Initializer))
           return false;
+        ++InitIndex;
       } else {
         // Initializer for a direct base class.
         if (const Record::Base *B = R->getBase(Init->getType())) {
           if (!this->emitGetPtrBasePop(B->Offset, Init))
             return false;
 
           if (!this->visitInitializer(Init))
             return false;
 
           if (!this->emitPopPtr(Initializer))
             return false;
+          // Base initializers don't increase InitIndex, since they don't count
+          // into the Record's fields.
         } else {
           const Record::Field *FieldToInit = R->getField(InitIndex);
           // Non-primitive case. Get a pointer to the field-to-initialize
           // on the stack and recurse into visitInitializer().
           if (!this->emitGetPtrField(FieldToInit->Offset, Init))
             return false;
 
           if (!this->visitInitializer(Init))
             return false;
 
           if (!this->emitPopPtr(Initializer))
             return false;
+          ++InitIndex;
         }
       }
-      ++InitIndex;
     }
 
     return true;
   } else if (const CallExpr *CE = dyn_cast<CallExpr>(Initializer)) {
     // RVO functions expect a pointer to initialize on the stack.
     // Dup our existing pointer so it has its own copy to use.
     if (!this->emitDupPtr(Initializer))
       return false;

clang/test/AST/Interp/cxx20.cpp

struct Outer {
     static NotConstexpr Val;
   };
 
   constexpr Outer::~Outer() {}
 
   constexpr Outer O;
   static_assert(O.bar() == 12);
 }
+
+namespace BaseAndFieldInit {
+  struct A {
+    int a;
+  };
+
+  struct B : A {
+    int b;
+  };
+
+  struct C : B {
+    int c;
+  };
+
+  constexpr C c = {1,2,3};
+}