[clang][Interp] Add back Run() call

[tbaeder]

Summary

We need to run the functions we compiled immediately after to check if
they can ever be a constant expression.

I removed this before, thinking it was unneeded. Turns out it is needed to get the "constexpr function never produces a constant expression" diagnostics.

[shafik]

clang/lib/AST/Interp/Interp.h

1314

Why did you add these checks calling checkingPotentialConstantExpression for?

[tbaeder]

clang/lib/AST/Interp/Interp.h

1314

The RVO pointer needs to be on the stack when calling a function (much like the this pointer). In the context of the Run call after compiling a function, it cannot exist and so we can't return anything here. This is similar to the pre-existing check in This() just above this function.

[shafik]

LGTM

clang/lib/AST/Interp/Interp.h

1314

Ahhh that makes sense. Can you add some comments, not sure where the right place is b/c this feels very opaque and I am not sure how I would figure this out otherwise.

clang/lib/AST/Interp/Context.cpp

if (auto R = ByteCodeStmtGen<ByteCodeEmitter>(*this, *P).compileFunc(FD)) {
         Parent.FFDiag(Err.getRange().getBegin(),
                       diag::err_experimental_clang_interp_failed)
             << Err.getRange();
       });
       return false;
     }
   }
 
+  APValue DummyResult;
+  if (!Run(Parent, Func, DummyResult)) {
+    return false;
+  }
+
   return Func->isConstexpr();
 }
 
 bool Context::evaluateAsRValue(State &Parent, const Expr *E, APValue &Result) {
   assert(Stk.empty());
   ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
   if (Check(Parent, C.interpretExpr(E))) {
     assert(Stk.empty());

clang/lib/AST/Interp/Interp.h

if (!CheckThis(S, OpPC, This))
     return false;
 
   S.Stk.push<Pointer>(This);
   return true;
 }
 
 inline bool RVOPtr(InterpState &S, CodePtr OpPC) {
   assert(S.Current->getFunction()->hasRVO());
+  if (S.checkingPotentialConstantExpression())
+    return false;
   S.Stk.push<Pointer>(S.Current->getRVOPtr());
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // Shr, Shl
 //===----------------------------------------------------------------------===//
 
inline bool ExpandPtr(InterpState &S, CodePtr OpPC) {
   return true;
 }
 
 inline bool Call(InterpState &S, CodePtr &PC, const Function *Func) {
   auto NewFrame = std::make_unique<InterpFrame>(S, Func, PC);
   Pointer ThisPtr;
   if (Func->hasThisPointer()) {
     ThisPtr = NewFrame->getThis();
-    if (!CheckInvoke(S, PC, ThisPtr)) {
+    if (!CheckInvoke(S, PC, ThisPtr))
+      return false;
+
+    if (S.checkingPotentialConstantExpression())
       return false;
-    }
   }
 
   if (!CheckCallable(S, PC, Func))
     return false;
 
   InterpFrame *FrameBefore = S.Current;
   S.Current = NewFrame.get();
 

clang/lib/AST/Interp/Interp.cpp

if (F->isVirtual()) {
     if (!S.getLangOpts().CPlusPlus20) {
       const SourceLocation &Loc = S.Current->getLocation(OpPC);
       S.CCEDiag(Loc, diag::note_constexpr_virtual_call);
       return false;
     }
   }
 
   if (!F->isConstexpr()) {
+    // Don't emit anything if we're checking for a potential constant
+    // expression. That will happen later when actually executing.
+    if (S.checkingPotentialConstantExpression())
+      return false;
+
     const SourceLocation &Loc = S.Current->getLocation(OpPC);
     if (S.getLangOpts().CPlusPlus11) {
       const FunctionDecl *DiagDecl = F->getDecl();
 
       // If this function is not constexpr because it is an inherited
       // non-constexpr constructor, diagnose that directly.
       auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
       if (CD && CD->isInheritingConstructor()) {

clang/test/AST/Interp/arrays.cpp

 public:
   int a;
   constexpr A(int m = 2) : a(10 + m) {}
 };
 class AU {
 public:
   int a;
   constexpr AU() : a(5 / 0) {} // expected-warning {{division by zero is undefined}} \
-                               // expected-note {{division by zero}} \
+                               // expected-note 2{{division by zero}} \
+                               // expected-error {{never produces a constant expression}} \
                                // ref-error {{never produces a constant expression}} \
                                // ref-note 2{{division by zero}} \
                                // ref-warning {{division by zero is undefined}}
 };
 class B {
 public:
   A a[2];
   constexpr B() {}
namespace IncDec {
 
   constexpr int getSecondToLast2() {
     const int *e = E + 3;
     --e;
     return *e;
   }
   static_assert(getSecondToLast2() == 3, "");
 
-  constexpr int bad1() { // ref-error {{never produces a constant expression}}
+  constexpr int bad1() { // ref-error {{never produces a constant expression}} \
+                         // expected-error {{never produces a constant expression}}
     const int *e =  E + 3;
     e++; // This is fine because it's a one-past-the-end pointer
-    return *e; // expected-note {{read of dereferenced one-past-the-end pointer}} \
+    return *e; // expected-note 2{{read of dereferenced one-past-the-end pointer}} \
                // ref-note 2{{read of dereferenced one-past-the-end pointer}}
   }
   static_assert(bad1() == 0, ""); // expected-error {{not an integral constant expression}} \
                                   // expected-note {{in call to}} \
                                   // ref-error {{not an integral constant expression}} \
                                   // ref-note {{in call to}}
 
-  constexpr int bad2() { // ref-error {{never produces a constant expression}}
+  constexpr int bad2() { // ref-error {{never produces a constant expression}} \
+                         // expected-error {{never produces a constant expression}}
     const int *e = E + 4;
-    e++; // expected-note {{cannot refer to element 5 of array of 4 elements}} \
+    e++; // expected-note 2{{cannot refer to element 5 of array of 4 elements}} \
          // ref-note 2{{cannot refer to element 5 of array of 4 elements}}
     return *e; // This is UB as well
   }
   static_assert(bad2() == 0, ""); // expected-error {{not an integral constant expression}} \
                                   // expected-note {{in call to}} \
                                   // ref-error {{not an integral constant expression}} \
                                   // ref-note {{in call to}}
 
 
-  constexpr int bad3() { // ref-error {{never produces a constant expression}}
+  constexpr int bad3() { // ref-error {{never produces a constant expression}} \
+                         // expected-error {{never produces a constant expression}}
     const int *e = E;
-    e--; // expected-note {{cannot refer to element -1 of array of 4 elements}} \
+    e--; // expected-note 2{{cannot refer to element -1 of array of 4 elements}} \
          // ref-note 2{{cannot refer to element -1 of array of 4 elements}}
     return *e; // This is UB as well
   }
    static_assert(bad3() == 0, ""); // expected-error {{not an integral constant expression}} \
                                    // expected-note {{in call to}} \
                                    // ref-error {{not an integral constant expression}} \
                                   // ref-note {{in call to}}
 };

clang/test/AST/Interp/literals.cpp

constexpr int uninit() {
     int a;
     ++a; // ref-note {{increment of uninitialized}} \
          // FIXME: Should also be rejected by new interpreter
     return 1;
   }
   static_assert(uninit(), ""); // ref-error {{not an integral constant expression}} \
                                // ref-note {{in call to 'uninit()'}}
 
-  constexpr int OverFlow() { // ref-error {{never produces a constant expression}}
+  constexpr int OverFlow() { // ref-error {{never produces a constant expression}} \
+                             // expected-error {{never produces a constant expression}}
     int a = INT_MAX;
     ++a; // ref-note 2{{is outside the range}} \
-         // expected-note {{is outside the range}}
+         // expected-note 2{{is outside the range}}
     return -1;
   }
   static_assert(OverFlow() == -1, "");  // expected-error {{not an integral constant expression}} \
                                         // expected-note {{in call to 'OverFlow()'}} \
                                         // ref-error {{not an integral constant expression}} \
                                         // ref-note {{in call to 'OverFlow()'}}
 
 
-  constexpr int UnderFlow() { // ref-error {{never produces a constant expression}}
+  constexpr int UnderFlow() { // ref-error {{never produces a constant expression}} \
+                              // expected-error {{never produces a constant expression}}
     int a = INT_MIN;
     --a; // ref-note 2{{is outside the range}} \
-         // expected-note {{is outside the range}}
+         // expected-note 2{{is outside the range}}
     return -1;
   }
   static_assert(UnderFlow() == -1, "");  // expected-error {{not an integral constant expression}} \
                                          // expected-note {{in call to 'UnderFlow()'}} \
                                          // ref-error {{not an integral constant expression}} \
                                          // ref-note {{in call to 'UnderFlow()'}}
 
   constexpr int getTwo() {

clang/test/AST/Interp/records.cpp

 }
 static_assert(locals() == 10, "");
 
 namespace thisPointer {
   struct S {
     constexpr int get12() { return 12; }
   };
 
-  constexpr int foo() { // ref-error {{never produces a constant expression}}
+  constexpr int foo() { // ref-error {{never produces a constant expression}} \
+                        // expected-error {{never produces a constant expression}}
     S *s = nullptr;
     return s->get12(); // ref-note 2{{member call on dereferenced null pointer}} \
-                       // expected-note {{member call on dereferenced null pointer}}
+                       // expected-note 2{{member call on dereferenced null pointer}}
 
   }
   static_assert(foo() == 12, ""); // ref-error {{not an integral constant expression}} \
                                   // ref-note {{in call to 'foo()'}} \
                                   // expected-error {{not an integral constant expression}} \
                                   // expected-note {{in call to 'foo()'}}
 };
 

clang/test/AST/Interp/shifts.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++20 -verify %s
 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++17 -verify=cxx17 %s
 // RUN: %clang_cc1 -std=c++20 -verify=ref %s
 // RUN: %clang_cc1 -std=c++17 -verify=ref-cxx17 %s
 
 #define INT_MIN (~__INT_MAX__)
 
 
 namespace shifts {
   constexpr void test() { // ref-error {{constexpr function never produces a constant expression}} \
-                          // ref-cxx17-error {{constexpr function never produces a constant expression}}
+                          // ref-cxx17-error {{constexpr function never produces a constant expression}} \
+                          // expected-error {{constexpr function never produces a constant expression}} \
+                          // cxx17-error {{constexpr function never produces a constant expression}} \
 
     char c; // cxx17-warning {{uninitialized variable}} \
             // ref-cxx17-warning {{uninitialized variable}}
 
     c = 0 << 0;
     c = 0 << 1;
     c = 1 << 0;
     c = 1 << -0;
     c = 1 >> -0;
     c = 1 << -1; // expected-warning {{shift count is negative}} \
+                 // expected-note {{negative shift count -1}} \
+                 // cxx17-note {{negative shift count -1}} \
                  // cxx17-warning {{shift count is negative}} \
                  // ref-warning {{shift count is negative}} \
                  // ref-note {{negative shift count -1}} \
                  // ref-cxx17-warning {{shift count is negative}} \
                  // ref-cxx17-note {{negative shift count -1}}
 
     c = 1 >> -1; // expected-warning {{shift count is negative}} \
                  // cxx17-warning {{shift count is negative}} \