[clang] fix error detection in consteval calls

[Tyker]

Summary

code like:

consteval int f() {
  int *A = new int(0);
  return *A;
}

int i1 = f();

currently doesn't generate any error.

maybe a better solution is to make CheckMemoryLeaks return false when there is memory leaks.

[rsmith]

Given the comment at the start of lib/AST/ExprConstant.cpp, this seems reasonable to me. I do wonder if it'd be better to return an enum constant/not-constant-but-foldable/not-foldable from the evaluator, rather than just a bool. But not as part of this patch :)

clang/lib/Sema/SemaExpr.cpp

 }
 
 static void EvaluateAndDiagnoseImmediateInvocation(
     Sema &SemaRef, Sema::ImmediateInvocationCandidate Candidate) {
   llvm::SmallVector<PartialDiagnosticAt, 8> Notes;
   Expr::EvalResult Eval;
   Eval.Diag = &Notes;
   ConstantExpr *CE = Candidate.getPointer();
-  if (!CE->EvaluateAsConstantExpr(Eval, Expr::EvaluateForCodeGen,
-                                  SemaRef.getASTContext(), true)) {
+  bool Result = CE->EvaluateAsConstantExpr(Eval, Expr::EvaluateForCodeGen,
+                                           SemaRef.getASTContext(), true);
+  if (!Result || !Notes.empty()) {
     Expr *InnerExpr = CE->getSubExpr()->IgnoreImplicit();
     FunctionDecl *FD = nullptr;
     if (auto *Call = dyn_cast<CallExpr>(InnerExpr))
       FD = cast<FunctionDecl>(Call->getCalleeDecl());
     else if (auto *Call = dyn_cast<CXXConstructExpr>(InnerExpr))
       FD = Call->getConstructor();
     else
       llvm_unreachable("unhandled decl kind");

clang/test/SemaCXX/cxx2a-consteval.cpp

void test() {
   { int k = (A().ret_a(), A().ret_i()); }
   { int k = (const_a_ref(A().ret_a()), A().ret_i()); }//
 }
 
 }
 
 namespace alloc {
 
+consteval int f() {
+  int *A = new int(0);
+// expected-note@-1+ {{allocation performed here was not deallocated}}
+  return *A;
+}
+
+int i1 = f(); // expected-error {{is not a constant expression}}
+
 struct A {
   int* p = new int(42);
   // expected-note@-1+ {{heap allocation performed here}}
   consteval int ret_i() const { return p ? *p : 0; }
   consteval A ret_a() const { return A{}; }
   constexpr ~A() { delete p; }
 };