[AST] Enhance the const expression evaluator to support error-dependent exprs.

[hokein]

Summary

Fix a crash when evaluating a constexpr function which contains
recovery-exprs. https://bugs.llvm.org/show_bug.cgi?id=46837

Would be nice to have constant expression evaluator support general template
value-dependent expressions, but it requires more work.

This patch is a good start I think, to handle the error-only
value-dependent expressions.

[erichkeane]

Based on richard's suggestions, that seems about right. However I believe all the asserts should have a message to go along with them as we typicaly do.

[rsmith]

clang/lib/AST/ExprConstant.cpp

4885

This should not result in failure when checking for a potential constant expression; if an expression contains errors we should treat it as being potentially constant, because (depending on how the error is resolved) it could be constant. We should noteSideEffect() here and continue unless it asks us to stop.

I guess I'm thinking of something like:

if (E->isValueDependent()) {
  if (E->noteSideEffect())
    return ESR_Succeeded;
  assert(E->containsErrors() && "non-value-dependent expression should never reach valid value-dependent expression");
  return ESR_Failed;
}

It might also be interesting to produce a diagnostic saying that evaluation failed due to a prior error on the ESR_Failed path; we could special-case that diagnostic when we diagnose expressions that are supposed to be constant but aren't in order to fully suppress the follow-on diagnostic.

(Same comment on all the below instances of this same pattern; adding a helper function for the above seems warranted.)

[rsmith]

In D84637#2175681, @erichkeane wrote:

Based on richard's suggestions, that seems about right. However I believe all the asserts should have a message to go along with them as we typicaly do.

In this case, the asserts are enforcing AST invariants, so I think they're OK without diagnostics.

[hokein]

address review comments:

• treat contains-errors expression as being potentially constant;
• handle the value-dependent expressions for EvaluateInPlace;
• remove the bailing out for constructor initializers that contains errors;

[hokein]

update

[hokein]

clang/lib/AST/ExprConstant.cpp

4959

The if stmt (the same to while, for) is tricky -- if the condition is value-dependent, then we don't know which branch we should run into.

• returning a ESR_Succeeded may lead to a bogus diagnostic ("reach the end of the function");
• returning a ESR_Failed may lead to a bogus diagnostic ("never produce a constexpr");

I guess what we want is to stop the evaluation, and indicate that we hit a value-dependent expression and we don't know how to evaluate it, but still treat the constexpr function as potential constexpr (but no extra diagnostics being emitted), but the current EvalStmtResult is not sufficient, maybe we need a new enum.

[hokein]

friendly ping @rsmith, the patch is ready for another round of review. Would be nice to have it in clang11.

[hokein]

friendly ping @rsmith.

[rsmith]

clang/lib/AST/ExprConstant.cpp

4583

The initializer might also be null because the variable is type-dependent (eg, X<contains_errors> x;), in which case assuming default-init is wrong. We should check for that and treat it like a value-dependent initializer.

4959

We should only produce the "never produce a constant expression" diagnostic if we also produce a CCEDiag/FFDiag, so I think returning ESR_Failed here should work.

4959

Should this check live in EvaluateCond instead?

5051

Missing value dependence check here.

7894–7895

How does this happen? I would expect the dependence of the subexpression to be reflected in the MaterializeTemporaryExpr.

8438

How does this happen?

9143

How does this happen? Do we not propagate value-dependence from initializers to new-expressions?

[hokein]

address review comments.

[hokein]

clang/lib/AST/ExprConstant.cpp

4583

I think you're right, added the check here, but unfortunately I didn't see noticeable behavior changes, and didn't manage to construct one (I confirmed that decltype(invalid()) x; will trigger this path).

4959

Should this check live in EvaluateCond instead?

there is a subtle difference -- doing it outside (not matter succeed or fail) will stop any execution of the following code, while doing it in EvaluateCond may continue the remaining code path if it succeeds, which may introduce bogus diagnostics, e.g. emitting a diagnostic constexpr evaluation hit maximum step limit; possible infinite loop? for the following example.

constexpr int foo() {
  while (invalid()) {} 
  return 1;
}

Another point is that -- looks like if we just return false if it is a value-dependent expr in EvaluateCond, it improves diagnostics ( function never produces and reached end of diagnostics are suppressed) for the following example

 constexpr int test4() { // expected-error {{constexpr function never produces a constant expression}}
  if (invalid()) // expected-error {{use of undeclared identifier}}
    return 1;
  else
    return 0;
}  // expected-note {{control reached end of constexpr function}}

5051

ah, right. Added one test.

8438

I think this is a similar escaped case to CXXNewExpr as well.

9143

this happens in the following case (during the constructor call), the dependence-bits of CXXNewExpr are correct -- it is value-dependent, instantiation-dependent, contains-errors.

However, we run into this codepath because the CXXDefaultInitExpr doesn't have any dependence-bits being set, in fact, it is always none, I think this is a bug, fixing in https://reviews.llvm.org/D87382.

With that fix, we don't need this check anymore (the same to other two places).

struct A {
  int* p = new int(invalid());
}
constexpr int test2() {
  A a;
  return 1;
}

[hokein]

rebase

[hokein]

@rsmith this patch should be ready for another round of review.

[hokein]

friendly ping @rsmith :)

[rsmith]

There are a couple of cases where you're returning EvalStmtResult from a function with a bool return type, that I'd like to see fixed before this lands.

All the other comments are directed towards producing more precise behavior when evaluating a function containing errors / value-dependent constructs. I don't think there's any need to block fixing the crasher here on improving the diagnostics, so I'm happy if you ignore these and commit as-is (other than fixing the return type issue), but I think we'll want to look at these diagnostic improvements at some point.

clang/lib/AST/ExprConstant.cpp

4572

I think it would be slightly better if the dependent cases in this function returned noteSideEffect() instead of false.

4598–4610

This function should bail out as soon as it sees an error. Otherwise, I think

constexpr void f() { int a = error(), b = a; }

... will to produce a hard error when evaluating b, because its initializer appears to read from an uninitialized variable.

4612

Given the number of places below that seem to need to branch on the return value rather than returning it directly, and the use from contexts other than statement evaluation, I think it might be better for this function to return bool.

4852

If this returns ESR_Succeeded, we should keep going rather than returning that value. Otherwise we'll do the wrong thing for cases like:

constexpr bool f() {
  for (int n = 0; ; ++n, error()) { if (n == 1) return true; }
  throw "bad";
}

... because evaluation of the for loop (but not the enclosing function) will terminate at the value-dependent increment expression, so we'll think that all evaluations of this function unconditionally throw.

5011

If the condition is value-dependent, I think we should return ESR_Failed here: we don't know whether to keep going or terminate the loop, and either answer will be wrong in some cases.

5051

As above, I think we need to keep going on ESR_Succeeded here.

5101

We should return ESR_Failed unconditionally here, because we don't know which statement to execute next.

5127

As above, I think we need to keep going on ESR_Succeeded here.

5881–5883

This is returning an EvalStmtResult from a function with a bool return type. It'd also be a bit more precise to keep going after a value-dependent expression here, so that we can diagnose non-constant constructs in the body after a typo in the mem-initializer list.

6027–6028

Similarly, it'd be a bit more precise to keep going if EvaluateDependentExpr says it succeeded.

[rsmith]

(Accepted subject to previous comment.)

[hokein]

rebase and address review comments.

[hokein]

In D84637#2345353, @rsmith wrote:

There are a couple of cases where you're returning EvalStmtResult from a function with a bool return type, that I'd like to see fixed before this lands.

All the other comments are directed towards producing more precise behavior when evaluating a function containing errors / value-dependent constructs. I don't think there's any need to block fixing the crasher here on improving the diagnostics, so I'm happy if you ignore these and commit as-is (other than fixing the return type issue), but I think we'll want to look at these diagnostic improvements at some point.

thanks for the useful comments, I think I have addressed most of them and added more tests.

clang/lib/AST/ExprConstant.cpp

 //===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Expr constant evaluator.
void CallStackFrame::describe(raw_ostream &Out) {
 
   Out << ')';
 }
 
 /// Evaluate an expression to see if it had side-effects, and discard its
 /// result.
 /// \return \c true if the caller should keep evaluating.
 static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
+  assert(!E->isValueDependent());
   APValue Scratch;
   if (!Evaluate(Scratch, Info, E))
     // We don't need the value, but we might have skipped a side effect here.
     return Info.noteSideEffect();
   return true;
 }
 
 /// Should this call expression be treated as a string literal?
case APValue::AddrLabelDiff:
     return false;
   }
 
   llvm_unreachable("unknown APValue kind");
 }
 
 static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
                                        EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition");
   APValue Val;
   if (!Evaluate(Val, Info, E))
     return false;
   return HandleConversionToBool(Val, Result);
 }
 
 template<typename T>
enum EvalStmtResult {
   ESR_Continue,
   /// Hit a 'break' statement.
   ESR_Break,
   /// Still scanning for 'case' or 'default' statement.
   ESR_CaseNotFound
 };
 }
 
 static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD) {
   // We don't need to evaluate the initializer for a static local.
   if (!VD->hasLocalStorage())
     return true;
 
   LValue Result;
   APValue &Val =
       Info.CurrentCall->createTemporary(VD, VD->getType(), true, Result);
 
   const Expr *InitE = VD->getInit();
   if (!InitE)
     return getDefaultInitValue(VD->getType(), Val);
 
   if (InitE->isValueDependent())
     return false;
 
   if (!EvaluateInPlace(Val, Info, Result, InitE)) {
     // Wipe out any partially-computed value, to allow tracking that this
     // evaluation failed.
     Val = APValue();
     return false;
   }
 
   return true;
 }
 
 static bool EvaluateDecl(EvalInfo &Info, const Decl *D) {
   bool OK = true;
 
   if (const VarDecl *VD = dyn_cast<VarDecl>(D))
     OK &= EvaluateVarDecl(Info, VD);
 
   if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(D))
     for (auto *BD : DD->bindings())
       if (auto *VD = BD->getHoldingVar())
         OK &= EvaluateDecl(Info, VD);
 
   return OK;
 }
 
 
 /// Evaluate a condition (either a variable declaration or an expression).
 static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
                          const Expr *Cond, bool &Result) {
+  assert(!Cond->isValueDependent());
   FullExpressionRAII Scope(Info);
   if (CondDecl && !EvaluateDecl(Info, CondDecl))
     return false;
   if (!EvaluateAsBooleanCondition(Cond, Result, Info))
     return false;
   return Scope.destroy();
 }
 
case ESR_CaseNotFound:
     // expression. We have no intention of supporting that.
     Info.FFDiag(Found->getBeginLoc(),
                 diag::note_constexpr_stmt_expr_unsupported);
     return ESR_Failed;
   }
   llvm_unreachable("Invalid EvalStmtResult!");
 }
 
+static EvalStmtResult EvaluateDependentExpr(const Expr *E, EvalInfo &Info) {
+  assert(E->isValueDependent());
+  if (Info.noteSideEffect())
+    return ESR_Succeeded;
+  assert(E->containsErrors() && "valid value-dependent expression should never "
+                                "reach invalid code path.");
+  return ESR_Failed;
+}
+
 // Evaluate a statement.
 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
                                    const Stmt *S, const SwitchCase *Case) {
   if (!Info.nextStep(S))
     return ESR_Failed;
 
   // If we're hunting down a 'case' or 'default' label, recurse through
   // substatements until we hit the label.
case Stmt::ForStmtClass: {
       }
 
       EvalStmtResult ESR =
           EvaluateLoopBody(Result, Info, FS->getBody(), Case);
       if (ESR != ESR_Continue)
         return ESR;
       if (FS->getInc()) {
         FullExpressionRAII IncScope(Info);
         if (!EvaluateIgnoredValue(Info, FS->getInc()) || !IncScope.destroy())
           return ESR_Failed;
       }
       break;
     }
 
     case Stmt::DeclStmtClass: {
       // Start the lifetime of any uninitialized variables we encounter. They
       // might be used by the selected branch of the switch.
if (Case) {
     default:
       return ESR_CaseNotFound;
     }
   }
 
   switch (S->getStmtClass()) {
   default:
     if (const Expr *E = dyn_cast<Expr>(S)) {
+      if (E->isValueDependent())
+        return EvaluateDependentExpr(E, Info);
       // Don't bother evaluating beyond an expression-statement which couldn't
       // be evaluated.
       // FIXME: Do we need the FullExpressionRAII object here?
       // VisitExprWithCleanups should create one when necessary.
       FullExpressionRAII Scope(Info);
       if (!EvaluateIgnoredValue(Info, E) || !Scope.destroy())
         return ESR_Failed;
       return ESR_Succeeded;
     }
for (const auto *D : DS->decls()) {
         return ESR_Failed;
     }
     return ESR_Succeeded;
   }
 
   case Stmt::ReturnStmtClass: {
     const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
     FullExpressionRAII Scope(Info);
+    if (RetExpr && RetExpr->isValueDependent())
+      return EvaluateDependentExpr(RetExpr, Info) == ESR_Succeeded? ESR_Returned : ESR_Failed;
     if (RetExpr &&
         !(Result.Slot
               ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
               : Evaluate(Result.Value, Info, RetExpr)))
       return ESR_Failed;
     return Scope.destroy() ? ESR_Returned : ESR_Failed;
   }
 
case Stmt::IfStmtClass: {
     if (const Stmt *Init = IS->getInit()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && !Scope.destroy())
           return ESR_Failed;
         return ESR;
       }
     }
+    if (IS->getCond()->isValueDependent())
+      return EvaluateDependentExpr(IS->getCond(), Info);
     bool Cond;
     if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
       return ESR_Failed;
 
     if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && !Scope.destroy())
           return ESR_Failed;
         return ESR;
       }
     }
     return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
   }
 
   case Stmt::WhileStmtClass: {
     const WhileStmt *WS = cast<WhileStmt>(S);
     while (true) {
+      if (WS->getCond()->isValueDependent())
+        return EvaluateDependentExpr(WS->getCond(), Info);
       BlockScopeRAII Scope(Info);
       bool Continue;
       if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(),
                         Continue))
         return ESR_Failed;
       if (!Continue)
         break;
 
case Stmt::DoStmtClass: {
     const DoStmt *DS = cast<DoStmt>(S);
     bool Continue;
     do {
       EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case);
       if (ESR != ESR_Continue)
         return ESR;
       Case = nullptr;
 
+      if (DS->getCond()->isValueDependent())
+        return EvaluateDependentExpr(DS->getCond(), Info);
       FullExpressionRAII CondScope(Info);
       if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info) ||
           !CondScope.destroy())
         return ESR_Failed;
     } while (Continue);
     return ESR_Succeeded;
   }
 
   case Stmt::ForStmtClass: {
     const ForStmt *FS = cast<ForStmt>(S);
     BlockScopeRAII ForScope(Info);
     if (FS->getInit()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && !ForScope.destroy())
           return ESR_Failed;
         return ESR;
       }
     }
     while (true) {
+      if (FS->getCond() && FS->getCond()->isValueDependent())
+        return EvaluateDependentExpr(FS->getCond(), Info);
       BlockScopeRAII IterScope(Info);
       bool Continue = true;
       if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(),
                                          FS->getCond(), Continue))
         return ESR_Failed;
       if (!Continue)
         break;
 
       EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody());
       if (ESR != ESR_Continue) {
         if (ESR != ESR_Failed && (!IterScope.destroy() || !ForScope.destroy()))
           return ESR_Failed;
         return ESR;
       }
 
       if (FS->getInc()) {
         FullExpressionRAII IncScope(Info);
         if (!EvaluateIgnoredValue(Info, FS->getInc()) || !IncScope.destroy())
           return ESR_Failed;
       }
 
       if (!IterScope.destroy())
         return ESR_Failed;
     }
     return ForScope.destroy() ? ESR_Succeeded : ESR_Failed;
   }
if (ESR != ESR_Succeeded) {
       if (ESR != ESR_Failed && !Scope.destroy())
         return ESR_Failed;
       return ESR;
     }
 
     while (true) {
       // Condition: __begin != __end.
       {
+        if (FS->getCond()->isValueDependent())
+          return EvaluateDependentExpr(FS->getCond(), Info);
         bool Continue = true;
         FullExpressionRAII CondExpr(Info);
         if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info))
           return ESR_Failed;
         if (!Continue)
           break;
       }
 
       // User's variable declaration, initialized by *__begin.
       BlockScopeRAII InnerScope(Info);
       ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt());
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && (!InnerScope.destroy() || !Scope.destroy()))
           return ESR_Failed;
         return ESR;
       }
 
       // Loop body.
       ESR = EvaluateLoopBody(Result, Info, FS->getBody());
       if (ESR != ESR_Continue) {
         if (ESR != ESR_Failed && (!InnerScope.destroy() || !Scope.destroy()))
           return ESR_Failed;
         return ESR;
       }
-
+      if (FS->getInc()->isValueDependent())
+        return EvaluateDependentExpr(FS->getInc(), Info);
       // Increment: ++__begin
       if (!EvaluateIgnoredValue(Info, FS->getInc()))
         return ESR_Failed;
 
       if (!InnerScope.destroy())
         return ESR_Failed;
     }
 
if (!Info.Ctx.getLangOpts().CPlusPlus20 && isa<CXXMethodDecl>(Declaration) &&
       cast<CXXMethodDecl>(Declaration)->isVirtual())
     Info.CCEDiag(CallLoc, diag::note_constexpr_virtual_call);
 
   if (Definition && Definition->isInvalidDecl()) {
     Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
     return false;
   }
 
-  if (const auto *CtorDecl = dyn_cast_or_null<CXXConstructorDecl>(Definition)) {
-    for (const auto *InitExpr : CtorDecl->inits()) {
-      if (InitExpr->getInit() && InitExpr->getInit()->containsErrors())
-        return false;
-    }
-  }
-
   // Can we evaluate this function call?
   if (Definition && Definition->isConstexpr() && Body)
     return true;
 
   if (Info.getLangOpts().CPlusPlus11) {
     const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
 
     // If this function is not constexpr because it is an inherited
static bool HandleConstructorCall(const Expr *E, const LValue &This,
   // FIXME: Creating an APValue just to hold a nonexistent return value is
   // wasteful.
   APValue RetVal;
   StmtResult Ret = {RetVal, nullptr};
 
   // If it's a delegating constructor, delegate.
   if (Definition->isDelegatingConstructor()) {
     CXXConstructorDecl::init_const_iterator I = Definition->init_begin();
+    if ((*I)->getInit()->isValueDependent())
+      return EvaluateDependentExpr((*I)->getInit(), Info);
     {
       FullExpressionRAII InitScope(Info);
       if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()) ||
           !InitScope.destroy())
         return false;
     }
     return EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
   }
 
#endif
     } else {
       llvm_unreachable("unknown base initializer kind");
     }
 
     // Need to override This for implicit field initializers as in this case
     // This refers to innermost anonymous struct/union containing initializer,
     // not to currently constructed class.
     const Expr *Init = I->getInit();
+    if (Init->isValueDependent())
+      return EvaluateDependentExpr(Init, Info);
     ThisOverrideRAII ThisOverride(*Info.CurrentCall, &SubobjectParent,
                                   isa<CXXDefaultInitExpr>(Init));
     FullExpressionRAII InitScope(Info);
     if (!EvaluateInPlace(*Value, Info, Subobject, Init) ||
         (FD && FD->isBitField() &&
          !truncateBitfieldValue(Info, Init, *Value, FD))) {
       // If we're checking for a potential constant expression, evaluate all
       // initializers even if some of them fail.

 
 /// Evaluate an expression as an lvalue. This can be legitimately called on
 /// expressions which are not glvalues, in three cases:
 ///  * function designators in C, and
 ///  * "extern void" objects
 ///  * @selector() expressions in Objective-C
 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
                            bool InvalidBaseOK) {
+  assert(!E->isValueDependent());
   assert(E->isGLValue() || E->getType()->isFunctionType() ||
          E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E));
   return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
 }
 
 bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) {
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl()))
     return Success(FD);
if (E->getStorageDuration() == SD_Static) {
     *Value = APValue();
     Result.set(E);
   } else {
     Value = &Info.CurrentCall->createTemporary(
         E, E->getType(), E->getStorageDuration() == SD_Automatic, Result);
   }
 
   QualType Type = Inner->getType();
-
+  if (Inner->isValueDependent())
+    return EvaluateDependentExpr(Inner, Info);
   // Materialize the temporary itself.
   if (!EvaluateInPlace(*Value, Info, Result, Inner)) {
     *Value = APValue();
     return false;
   }
 
   // Adjust our lvalue to refer to the desired subobject.
   for (unsigned I = Adjustments.size(); I != 0; /**/) {
public:
   }
 
   // FIXME: Missing: @protocol, @selector
 };
 } // end anonymous namespace
 
 static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
                             bool InvalidBaseOK) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->hasPointerRepresentation());
   return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
 }
 
 bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
   if (E->getOpcode() != BO_Add &&
       E->getOpcode() != BO_Sub)
     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
case CK_IntegralToPointer: {
     }
   }
 
   case CK_ArrayToPointerDecay: {
     if (SubExpr->isGLValue()) {
       if (!evaluateLValue(SubExpr, Result))
         return false;
     } else {
+      if (SubExpr->isValueDependent())
+        return EvaluateDependentExpr(SubExpr, Info);
       APValue &Value = Info.CurrentCall->createTemporary(
           SubExpr, SubExpr->getType(), false, Result);
       if (!EvaluateInPlace(Value, Info, Result, SubExpr))
         return false;
     }
     // The result is a pointer to the first element of the array.
     auto *AT = Info.Ctx.getAsArrayType(SubExpr->getType());
     if (auto *CAT = dyn_cast<ConstantArrayType>(AT))
if (ResizedArrayILE) {
     if (!EvaluateArrayNewInitList(Info, Result, *Val, ResizedArrayILE,
                                   AllocType))
       return false;
   } else if (ResizedArrayCCE) {
     if (!EvaluateArrayNewConstructExpr(Info, Result, *Val, ResizedArrayCCE,
                                        AllocType))
       return false;
   } else if (Init) {
+    if (Init->isValueDependent())
+      return EvaluateDependentExpr(Init, Info);
     if (!EvaluateInPlace(*Val, Info, Result, Init))
       return false;
   } else if (!getDefaultInitValue(AllocType, *Val)) {
     return false;
   }
 
   // Array new returns a pointer to the first element, not a pointer to the
   // array.
public:
 
   bool VisitCastExpr(const CastExpr *E);
   bool VisitUnaryAddrOf(const UnaryOperator *E);
 };
 } // end anonymous namespace
 
 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
                                   EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isMemberPointerType());
   return MemberPointerExprEvaluator(Info, Result).Visit(E);
 }
 
 bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
   switch (E->getCastKind()) {
   default:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
for (const auto *Field : ClosureClass->fields()) {
     }
     ++CaptureIt;
   }
   return Success;
 }
 
 static bool EvaluateRecord(const Expr *E, const LValue &This,
                            APValue &Result, EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isRecordType() &&
          "can't evaluate expression as a record rvalue");
   return RecordExprEvaluator(Info, This, Result).Visit(E);
 }
 
 //===----------------------------------------------------------------------===//
 // Temporary Evaluation
 //
public:
   bool VisitLambdaExpr(const LambdaExpr *E) {
     return VisitConstructExpr(E);
   }
 };
 } // end anonymous namespace
 
 /// Evaluate an expression of record type as a temporary.
 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isRecordType());
   return TemporaryExprEvaluator(Info, Result).Visit(E);
 }
 
 //===----------------------------------------------------------------------===//
 // Vector Evaluation
 //===----------------------------------------------------------------------===//
 
bool VisitStringLiteral(const StringLiteral *E,
       expandStringLiteral(Info, E, Result, AllocType);
       return true;
     }
   };
 } // end anonymous namespace
 
 static bool EvaluateArray(const Expr *E, const LValue &This,
                           APValue &Result, EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue");
   return ArrayExprEvaluator(Info, This, Result).Visit(E);
 }
 
 static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This,
                                      APValue &Result, const InitListExpr *ILE,
                                      QualType AllocType) {
+  assert(!ILE->isValueDependent());
   assert(ILE->isRValue() && ILE->getType()->isArrayType() &&
          "not an array rvalue");
   return ArrayExprEvaluator(Info, This, Result)
       .VisitInitListExpr(ILE, AllocType);
 }
 
 static bool EvaluateArrayNewConstructExpr(EvalInfo &Info, LValue &This,
                                           APValue &Result,
                                           const CXXConstructExpr *CCE,
                                           QualType AllocType) {
+  assert(!CCE->isValueDependent());
   assert(CCE->isRValue() && CCE->getType()->isArrayType() &&
          "not an array rvalue");
   return ArrayExprEvaluator(Info, This, Result)
       .VisitCXXConstructExpr(CCE, This, &Result, AllocType);
 }
 
 // Return true iff the given array filler may depend on the element index.
 static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {

 ///
 /// GCC has a heinous extension which folds casts between pointer types and
 /// pointer-sized integral types. We support this by allowing the evaluation of
 /// an integer rvalue to produce a pointer (represented as an lvalue) instead.
 /// Some simple arithmetic on such values is supported (they are treated much
 /// like char*).
 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
                                     EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType());
   return IntExprEvaluator(Info, Result).Visit(E);
 }
 
 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
+  assert(!E->isValueDependent());
   APValue Val;
   if (!EvaluateIntegerOrLValue(E, Val, Info))
     return false;
   if (!Val.isInt()) {
     // FIXME: It would be better to produce the diagnostic for casting
     //        a pointer to an integer.
     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
     return false;
   }
   Result = Val.getInt();
   return true;
 }
 
 bool IntExprEvaluator::VisitSourceLocExpr(const SourceLocExpr *E) {
   APValue Evaluated = E->EvaluateInContext(
       Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
   return Success(Evaluated, E);
 }
 
 static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
                                EvalInfo &Info) {
+  assert(!E->isValueDependent());
   if (E->getType()->isFixedPointType()) {
     APValue Val;
     if (!FixedPointExprEvaluator(Info, Val).Visit(E))
       return false;
     if (!Val.isFixedPoint())
       return false;
 
     Result = Val.getFixedPoint();
     return true;
   }
   return false;
 }
 
 static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
                                         EvalInfo &Info) {
+  assert(!E->isValueDependent());
   if (E->getType()->isIntegerType()) {
     auto FXSema = Info.Ctx.getFixedPointSemantics(E->getType());
     APSInt Val;
     if (!EvaluateInteger(E, Val, Info))
       return false;
     Result = APFixedPoint(Val, FXSema);
     return true;
   } else if (E->getType()->isFixedPointType()) {
enum class CmpResult {
   Unordered,
 };
 }
 
 template <class SuccessCB, class AfterCB>
 static bool
 EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E,
                                  SuccessCB &&Success, AfterCB &&DoAfter) {
+  assert(!E->isValueDependent());
   assert(E->isComparisonOp() && "expected comparison operator");
   assert((E->getOpcode() == BO_Cmp ||
           E->getType()->isIntegralOrEnumerationType()) &&
          "unsupported binary expression evaluation");
   auto Error = [&](const Expr *E) {
     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
     return false;
   };
public:
   bool VisitUnaryReal(const UnaryOperator *E);
   bool VisitUnaryImag(const UnaryOperator *E);
 
   // FIXME: Missing: array subscript of vector, member of vector
 };
 } // end anonymous namespace
 
 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isRealFloatingType());
   return FloatExprEvaluator(Info, Result).Visit(E);
 }
 
 static bool TryEvaluateBuiltinNaN(const ASTContext &Context,
                                   QualType ResultTy,
                                   const Expr *Arg,
                                   bool SNaN,
public:
   bool VisitUnaryOperator(const UnaryOperator *E);
   bool VisitInitListExpr(const InitListExpr *E);
   bool VisitCallExpr(const CallExpr *E);
 };
 } // end anonymous namespace
 
 static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
                             EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isAnyComplexType());
   return ComplexExprEvaluator(Info, Result).Visit(E);
 }
 
 bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) {
   QualType ElemTy = E->getType()->castAs<ComplexType>()->getElementType();
   if (ElemTy->isRealFloatingType()) {
     Result.makeComplexFloat();
case CK_NonAtomicToAtomic:
                   : Evaluate(Result, Info, E->getSubExpr());
     }
   }
 };
 } // end anonymous namespace
 
 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
                            EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isAtomicType());
   return AtomicExprEvaluator(Info, This, Result).Visit(E);
 }
 
 //===----------------------------------------------------------------------===//
 // Void expression evaluation, primarily for a cast to void on the LHS of a
 // comma operator
 //===----------------------------------------------------------------------===//
if (!Info.HeapAllocs.erase(Pointer.Base.dyn_cast<DynamicAllocLValue>())) {
     Info.FFDiag(E, diag::note_constexpr_double_delete);
     return false;
   }
 
   return true;
 }
 
 static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
+  assert(!E->isValueDependent());
   assert(E->isRValue() && E->getType()->isVoidType());
   return VoidExprEvaluator(Info).Visit(E);
 }
 
 //===----------------------------------------------------------------------===//
 // Top level Expr::EvaluateAsRValue method.
 //===----------------------------------------------------------------------===//
 
 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
+  assert(!E->isValueDependent());
   // In C, function designators are not lvalues, but we evaluate them as if they
   // are.
   QualType T = E->getType();
   if (E->isGLValue() || T->isFunctionType()) {
     LValue LV;
     if (!EvaluateLValue(E, LV, Info))
       return false;
     LV.moveInto(Result);
static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
 
   // For any other type, in-place evaluation is unimportant.
   return Evaluate(Result, Info, E);
 }
 
 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
 /// lvalue-to-rvalue cast if it is an lvalue.
 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
+  assert(!E->isValueDependent());
   if (Info.EnableNewConstInterp) {
     if (!Info.Ctx.getInterpContext().evaluateAsRValue(Info, E, Result))
       return false;
   } else {
     if (E->getType().isNull())
       return false;
 
     if (!CheckLiteralType(Info, E))

 static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result,
                                       Expr::SideEffectsKind SEK) {
   return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
          (SEK < Expr::SE_AllowUndefinedBehavior && Result.HasUndefinedBehavior);
 }
 
 static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
                              const ASTContext &Ctx, EvalInfo &Info) {
+  assert(!E->isValueDependent());
   bool IsConst;
   if (FastEvaluateAsRValue(E, Result, Ctx, IsConst))
     return IsConst;
 
   return EvaluateAsRValue(Info, E, Result.Val);
 }
 
 static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult,
                           const ASTContext &Ctx,
                           Expr::SideEffectsKind AllowSideEffects,
                           EvalInfo &Info) {
+  assert(!E->isValueDependent());
   if (!E->getType()->isIntegralOrEnumerationType())
     return false;
 
   if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info) ||
       !ExprResult.Val.isInt() ||
       hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
     return false;
 
   return true;
 }
 
 static bool EvaluateAsFixedPoint(const Expr *E, Expr::EvalResult &ExprResult,
                                  const ASTContext &Ctx,
                                  Expr::SideEffectsKind AllowSideEffects,
                                  EvalInfo &Info) {
+  assert(!E->isValueDependent());
   if (!E->getType()->isFixedPointType())
     return false;
 
   if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info))
     return false;
 
   if (!ExprResult.Val.isFixedPoint() ||
       hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
bool Expr::isPotentialConstantExpr(const FunctionDecl *FD,
                                    SmallVectorImpl<
                                      PartialDiagnosticAt> &Diags) {
   // FIXME: It would be useful to check constexpr function templates, but at the
   // moment the constant expression evaluator cannot cope with the non-rigorous
   // ASTs which we build for dependent expressions.
   if (FD->isDependentContext())
     return true;
 
-  // Bail out if a constexpr constructor has an initializer that contains an
-  // error. We deliberately don't produce a diagnostic, as we have produced a
-  // relevant diagnostic when parsing the error initializer.
-  if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
-    for (const auto *InitExpr : Ctor->inits()) {
-      if (InitExpr->getInit() && InitExpr->getInit()->containsErrors())
-        return false;
-    }
-  }
+  // // Bail out if a constexpr constructor has an initializer that contains an
+  // // error. We deliberately don't produce a diagnostic, as we have produced a
+  // // relevant diagnostic when parsing the error initializer.
+  // if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
+  //   for (const auto *InitExpr : Ctor->inits()) {
+  //     if (InitExpr->getInit() && InitExpr->getInit()->containsErrors())
+  //       return false;
+  //   }
+  // }
   Expr::EvalStatus Status;
   Status.Diag = &Diags;
 
   EvalInfo Info(FD->getASTContext(), Status, EvalInfo::EM_ConstantExpression);
   Info.InConstantContext = true;
   Info.CheckingPotentialConstantExpression = true;
 
   // The constexpr VM attempts to compile all methods to bytecode here.

clang/test/SemaCXX/constexpr-function-recovery-crash.cpp

+// RUN: %clang_cc1 %s -std=c++20 -fsyntax-only -verify
+
+// verify no value-dependent-assertion crash in constexpr function body.
+class Foo {
+  constexpr Foo() {
+    while (invalid()) {} // expected-error {{use of undeclared identifier}}
+    if (invalid()) {} // expected-error {{use of undeclared identifier}}
+  }
+};
+
+constexpr void test1() {
+  while (invalid()) {} // expected-error {{use of undeclared identifier}}
+  if (invalid()) {} // expected-error {{use of undeclared identifier}}
+}
+
+struct A {
+  int* p = new int(invalid()); // expected-error {{use of undeclared identifier}}
+  constexpr ~A() { delete p; }
+};
+constexpr int test2() {
+  A a;
+  return 1;
+}
+
+constexpr int test3() {
+  return invalid(); // expected-error {{use of undeclared identifier}}
+}
+
+constexpr int test4() { // expected-error {{constexpr function never produces a constant expression}}
+  if (invalid()) // expected-error {{use of undeclared identifier}}
+    return 1;
+  else
+    return 0;
+// FIXME: remove the "control reached end" diagnostic note.
+}  // expected-note {{control reached end of constexpr function}}

clang/test/SemaCXX/enable_if.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s
 // RUN: %clang_cc1 -std=c++2a -verify %s
 typedef int (*fp)(int);
 int surrogate(int);
 struct Incomplete;  // expected-note{{forward declaration of 'Incomplete'}} \
                     // expected-note {{forward declaration of 'Incomplete'}}
 
 struct X {
   X() = default;  // expected-note{{candidate constructor not viable: requires 0 arguments, but 1 was provided}}

 }
 
 constexpr int A = templated<0>(); // expected-error{{no matching function for call to 'templated'}} expected-note@-4{{candidate disabled}}
 static_assert(templated<1>() == 1, "");
 
 template <int N> constexpr int callTemplated() { return templated<N>(); }
 
 constexpr int B = 10 + // expected-error {{initialized by a constant expression}}
-    callTemplated<0>(); // expected-error@-3{{no matching function for call to 'templated'}} expected-note{{in instantiation of function template}} expected-note@-10{{candidate disabled}} expected-note {{in call to 'callTemplated()'}} expected-note@-3 {{subexpression not valid in a constant expression}}
+    callTemplated<0>(); // expected-error@-3{{no matching function for call to 'templated'}} expected-note{{in instantiation of function template}} expected-note@-10{{candidate disabled}}
 static_assert(callTemplated<1>() == 1, "");
 }
 
 namespace variadic {
 void foo(int a, int b = 0, ...) __attribute__((enable_if(a && b, ""))); // expected-note 6{{disabled}}
 
 void testFoo() {
   foo(1, 1);

clang/test/SemaCXX/invalid-constructor-init.cpp

 // RUN: %clang_cc1 -frecovery-ast -verify %s
 
 struct X {
   int Y;
-  constexpr X() // expected-error {{constexpr constructor never produces}}
+  constexpr X()
       : Y(foo()) {} // expected-error {{use of undeclared identifier 'foo'}}
 };
 // no crash on evaluating the constexpr ctor.
 constexpr int Z = X().Y; // expected-error {{constexpr variable 'Z' must be initialized by a constant expression}}
 
 struct X2 {
   int Y = foo();    // expected-error {{use of undeclared identifier 'foo'}} \
                  // expected-note {{subexpression not valid in a constant expression}}
   constexpr X2() {} // expected-error {{constexpr constructor never produces a constant expression}}
 };
 
 struct X3 {
   int Y;
-  constexpr X3() // expected-error {{constexpr constructor never produces}}
+  constexpr X3()
       : Y(({foo();})) {} // expected-error {{use of undeclared identifier 'foo'}}
 };
 
 struct CycleDelegate {
   int Y;
   CycleDelegate(int)
       : Y(foo()) {} // expected-error {{use of undeclared identifier 'foo'}}
   // no bogus "delegation cycle" diagnostic
   CycleDelegate(float) : CycleDelegate(1) {}
 };

clang/test/SemaCXX/recovery-expr-type.cpp

 
 template <typename T>
 struct AA {
   template <typename U>
   static constexpr int getB() { // expected-note{{candidate template ignored}}
     return 2;
   }
   static constexpr int foo2() {
-    return AA<T>::getB(); // expected-error{{no matching function for call to 'getB'}} \
-                          // expected-note {{subexpression not valid in a constant expression}}
+    return AA<T>::getB(); // expected-error{{no matching function for call to 'getB'}}
   }
 };
 // FIXME: should we suppress the "be initialized by a constant expression" diagnostic?
 constexpr auto x2 = AA<int>::foo2(); // expected-error {{be initialized by a constant expression}} \
-                                     // expected-note {{in instantiation of member function}} \
-                                     // expected-note {{in call to}}
+                                     // expected-note {{in instantiation of member function}}
 }
 
 // verify no assertion failure on violating value category.
 namespace test4 {
 int &&f(int);  // expected-note {{candidate function not viable}}
 int &&k = f(); // expected-error {{no matching function for call}}
 }