Give up on evaluating value-dependent potential constexpr before hitting the assertion.

[adamcz]

Summary

This addresses a new type of assert() crash since
f7f2e4261a98b2da519d58e7f6794b013cda7a4b.

EvaluateInPlace assumes it's never called on value-dependent expression,
but it is possible for this to happen when inside CallExpr and errors
were encountered earlier.

[adamcz]

Added [clang] in commit description

[hokein]

oops, this reminds me of the patch https://reviews.llvm.org/D84637 (I should have landed it, sorry), that patch should fix a general recovery-expr crash inside constexpr function body. I think the crash test should be fixed by that (let me check tomorrow).

[hokein]

In D91162#2400723, @hokein wrote:

oops, this reminds me of the patch https://reviews.llvm.org/D84637 (I should have landed it, sorry), that patch should fix a general recovery-expr crash inside constexpr function body. I think the crash test should be fixed by that (let me check tomorrow).

yeah, confirmed that D84637 will fix the crash, I also added the crash case there.

clang/lib/AST/ExprConstant.cpp

static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr,
   }
 
   return true;
 }
 
 static bool EvaluateCallArg(const ParmVarDecl *PVD, const Expr *Arg,
                             CallRef Call, EvalInfo &Info,
                             bool NonNull = false) {
+  if (Arg->isValueDependent())
+    return false;
+
   LValue LV;
   // Create the parameter slot and register its destruction. For a vararg
   // argument, create a temporary.
   // FIXME: For calling conventions that destroy parameters in the callee,
   // should we consider performing destruction when the function returns
   // instead?
   APValue &V = PVD ? Info.CurrentCall->createParam(Call, PVD, LV)
                    : Info.CurrentCall->createTemporary(Arg, Arg->getType(),

clang/test/SemaCXX/constexpr-value-dependent.cpp

+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify
+
+template<int x> constexpr int f(int y) {
+  return x * y;
+}
+
+// The error makes the CallExpr become potentially value-dependent. This used to
+// cause a crash.
+constexpr int test(int x) {
+  return f<1>(f<x>(1)); // expected-error {{no matching function for call to 'f'}} expected-note@-7{{candidate template ignored}}
+}