[clang][Interp] Fix record initialization via CallExpr subclasses

[tbaeder]

Summary

We can't just use VisitCallExpr() here, as that doesn't handle CallExpr
subclasses such as CXXMemberCallExpr.

I think the patch itself is mostly obvious, but I was wondering if it is the right time to add such RUN lines to existing test cases like I do here for test/SemaCXX/constexpr-nqueens.cpp.

[aaron.ballman]

I think the patch itself is mostly obvious, but I was wondering if it is the right time to add such RUN lines to existing test cases like I do here for test/SemaCXX/constexpr-nqueens.cpp.

If the tests are (mostly) passing without a bunch of FIXME comments, then yes, I think it's a great step to start running more of these tests with both constant expression engines.

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (const auto CtorExpr = dyn_cast<CXXConstructExpr>(Initializer)) {
 
     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;
 
-    return this->VisitCallExpr(CE);
+    return this->visit(CE);
   } else if (const auto *DIE = dyn_cast<CXXDefaultInitExpr>(Initializer)) {
     return this->visitInitializer(DIE->getExpr());
   } else if (const auto *CE = dyn_cast<CastExpr>(Initializer)) {
     return this->visitInitializer(CE->getSubExpr());
   } else if (const auto *CE = dyn_cast<CXXBindTemporaryExpr>(Initializer)) {
     return this->visitInitializer(CE->getSubExpr());
   } else if (const auto *ACO =
                  dyn_cast<AbstractConditionalOperator>(Initializer)) {

clang/test/AST/Interp/constexpr-nqueens.cpp

 constexpr Board tryBoard(const Board &Try,
                          int N, int Col, int Row, const Board &B) {
   return Try.Failed ? buildBoardScan(N, Col, Row, B) : Try;
 }
 constexpr Board buildBoardScan(int N, int Col, int Row, const Board &B) {
   return Row == N ? Board(0, true) :
          B.ok(Row, Col) ?
          tryBoard(buildBoardRecurse(N, Col + 1, B.addQueen(Row, Col)), // ref-note {{in call to '&Board()->addQueen(0, 0)}} \
-                                                                       // expected-note {{in call to '&B.addQueen(Row, Col).B.addQueen(Row, Col)->addQueen(0, 0)}}
+                                                                       // expected-note {{in call to '&Board().Board()->addQueen(0, 0)}}
                   N, Col, Row+1, B) :
          buildBoardScan(N, Col, Row + 1, B);
 }
 constexpr Board buildBoardRecurse(int N, int Col, const Board &B) {
   return Col == N ? B : buildBoardScan(N, Col, 0, B); // ref-note {{in call to 'buildBoardScan(8, 0, 0, Board())'}} \
                                                       // expected-note {{in call to 'buildBoardScan(8, 0, 0, Board().Board())}}
 }
 constexpr Board buildBoard(int N) {
   return buildBoardRecurse(N, 0, Board()); // ref-note {{in call to 'buildBoardRecurse(8, 0, Board())'}} \
                                            // expected-note {{in call to 'buildBoardRecurse(8, 0, Board().Board())'}}
 }
 
 constexpr Board q8 = buildBoard(8); // ref-error {{must be initialized by a constant expression}} \
                                     // ref-note {{in call to 'buildBoard(8)'}} \
                                     // expected-error {{must be initialized by a constant expression}} \
                                     // expected-note {{in call to 'buildBoard(8)'}}

clang/test/AST/Interp/records.cpp

 static_assert(I2.b == 25, "");
 
 class C {
   public:
     int a;
     int b;
 
   constexpr C() : a(100), b(200) {}
+
+  constexpr C get() const {
+    return *this;
+  }
 };
 
 constexpr C c;
 static_assert(c.a == 100, "");
 static_assert(c.b == 200, "");
 
+constexpr C c2 = C().get();
+static_assert(c.a == 100, "");
+static_assert(c.b == 200, "");
+
 constexpr int getB() {
   C c;
   int &j = c.b;
 
   j = j * 2;
 
   return c.b;
 }

clang/test/SemaCXX/constexpr-nqueens.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fexperimental-new-constant-interpreter %s
 
 typedef unsigned long uint64_t;
 
 struct Board {
   uint64_t State;
   bool Failed;
 
   constexpr Board() : State(0), Failed(false) {}