Prevent immediate evaluations inside of decltype

[wchilders]

Summary

This fixes an issue where immediate invocations were queued inside of decltype, resulting in decltype's operand being evaluated.

[Tyker]

clang/lib/Sema/SemaExpr.cpp

15389

the issue is seems more general than delctype. it applies to all unvealuated context (sizeof, alignof ...)

i think we should use Sema::isUnevaluatedContext() here.

[wchilders]

Thanks Tyker, you're right, there is a general problem that needs handled, if this is to be handled; I had a bit of tunnel vision here. However, I'm retracting/abandoning this patch entirely as upon further review, it's not standard compliant. The current situation, is actually the correct one (for now?).

From [7.7.13] of the working draft:

Note: A manifestly constant-evaluated expression is evaluated even in an unevaluated operand.

clang/lib/Sema/SemaExpr.cpp

if (auto *BO = dyn_cast<BinaryOperator>(E->IgnoreParenImpCasts())) {
     if (BO->getOpcode() == BO_Assign) {
       auto &LHSs = ExprEvalContexts.back().VolatileAssignmentLHSs;
       LHSs.erase(std::remove(LHSs.begin(), LHSs.end(), BO->getLHS()),
                  LHSs.end());
     }
   }
 }
 
+// Check to see if this expression is part of a decltype specifier.
+// We're not interested in evaluating this expression, immediately or otherwise.
+static bool isInDeclType(Sema &SemaRef) {
+  return SemaRef.ExprEvalContexts.back().ExprContext ==
+         Sema::ExpressionEvaluationContextRecord::EK_Decltype;
+}
+
 ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
   if (!E.isUsable() || !Decl || !Decl->isConsteval() || isConstantEvaluated() ||
-      RebuildingImmediateInvocation)
+      isInDeclType(*this) || RebuildingImmediateInvocation)
     return E;
 
   /// Opportunistically remove the callee from ReferencesToConsteval if we can.
   /// It's OK if this fails; we'll also remove this in
   /// HandleImmediateInvocations, but catching it here allows us to avoid
   /// walking the AST looking for it in simple cases.
   if (auto *Call = dyn_cast<CallExpr>(E.get()->IgnoreImplicit()))
     if (auto *DeclRef =

clang/test/SemaCXX/decltype-consteval.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2a %s
+// expected-no-diagnostics
+
+struct MaybeConsteval {
+  MaybeConsteval* ptr = nullptr;
+
+  consteval MaybeConsteval(bool Valid) : ptr(this) {
+    if (Valid) {
+      ptr = nullptr;
+    }
+  }
+};
+
+consteval decltype(MaybeConsteval(false)) foo() {
+  return { true };
+}