[clang][Interp] Fix InterpFrame::describe() for This pointers

[tbaeder]

Summary

Since we pass this via the stack, we need to account for it when
desribing the stack frame (parameters). This fixes a previously
commented-out test case.

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/InterpFrame.cpp

 void InterpFrame::describe(llvm::raw_ostream &OS) {
   const FunctionDecl *F = getCallee();
   auto *M = dyn_cast<CXXMethodDecl>(F);
   if (M && M->isInstance() && !isa<CXXConstructorDecl>(F)) {
     print(OS, This, S.getCtx(), S.getCtx().getRecordType(M->getParent()));
     OS << "->";
   }
   OS << *F << "(";
-  unsigned Off = Func->hasRVO() ? primSize(PT_Ptr) : 0;
+  unsigned Off = 0;
+
+  Off += Func->hasRVO() ? primSize(PT_Ptr) : 0;
+  Off += Func->hasThisPointer() ? primSize(PT_Ptr) : 0;
+
   for (unsigned I = 0, N = F->getNumParams(); I < N; ++I) {
     QualType Ty = F->getParamDecl(I)->getType();
 
     PrimType PrimTy;
     if (llvm::Optional<PrimType> T = S.Ctx.classify(Ty)) {
       PrimTy = *T;
     } else {
       PrimTy = PT_Ptr;

clang/test/AST/Interp/records.cpp

namespace DeriveFailures {
   // FIXME: This is currently not being diagnosed with the new constant interpreter.
   constexpr Derived D(12); // ref-error {{must be initialized by a constant expression}} \
                            // ref-note {{in call to 'Derived(12)'}} \
                            // ref-note {{declared here}} \
                            // expected-error {{must be initialized by a constant expression}}
   static_assert(D.Val == 0, ""); // ref-error {{not an integral constant expression}} \
                                  // ref-note {{initializer of 'D' is not a constant expression}}
 
-#if 0
-  // FIXME: This test is currently disabled because the failing constructor call
-  //   causes us to run into an assertion later on in the new interpreter.
-  //   Once that is fixed, we fail successfully but the diagnostic uses the
-  //   wrong value.
   struct AnotherBase {
     int Val;
     constexpr AnotherBase(int i) : Val(12 / i) {} //ref-note {{division by zero}} \
                                                   //expected-note {{division by zero}}
   };
 
   struct AnotherDerived : AnotherBase {
     constexpr AnotherDerived(int i) : AnotherBase(i) {}
   };
   constexpr AnotherBase Derp(0); // ref-error {{must be initialized by a constant expression}} \
                                  // ref-note {{in call to 'AnotherBase(0)'}} \
                                  // expected-error {{must be initialized by a constant expression}} \
-                                 // expected-note {{in call to 'AnotherBase(}}
-                                 // FIXME Previous note uses the wrong value
-#endif
+                                 // expected-note {{in call to 'AnotherBase(0)'}}
 
   struct YetAnotherBase {
     int Val;
     constexpr YetAnotherBase(int i) : Val(i) {}
   };
 
   struct YetAnotherDerived : YetAnotherBase {
     using YetAnotherBase::YetAnotherBase; //ref-note {{declared here}}