[clang] [Clang] Instantiate functions from constant evaluation. (PR #205557)

[Daniel M. Katz via cfe-commits]

================
@@ -22134,44 +22176,61 @@ bool Expr::EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx,
   // If this is a class template argument, it's required to have constant
   // destruction too.
   if (Kind == ConstantExprKind::ClassTemplateArgument &&
-      (!EvaluateDestruction(Ctx, Base, Result.Val, T, getBeginLoc(), Result,
-                            true) ||
+      (!EvaluateDestruction(Ctx, Info.getSemaProxy(), Base, Result.Val, T,
+                            E->getBeginLoc(), Result, true) ||
        Result.HasSideEffects)) {
     // FIXME: Prefix a note to indicate that the problem is lack of constant
     // destruction.
     return false;
   }
+
   return true;
 }
 
-bool Expr::EvaluateAsInitializer(const ASTContext &Ctx, const VarDecl *VD,
-                                 Expr::EvalResult &EStatus,
-                                 bool IsConstantInitialization) const {
+bool Expr::EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx,
+                                  ConstantExprKind Kind) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
-  assert(VD && "Need a valid VarDecl");
+  bool IsConst;
+  if (FastEvaluateAsRValue(this, Result.Val, Ctx, IsConst) &&
+      Result.Val.hasValue())
+    return true;
 
-  llvm::TimeTraceScope TimeScope("EvaluateAsInitializer", [&] {
-    std::string Name;
-    llvm::raw_string_ostream OS(Name);
-    VD->printQualifiedName(OS);
-    return Name;
-  });
+  ExprTimeTraceScope TimeScope(this, Ctx, "EvaluateAsConstantExpr");
+  EvaluationMode EM = EvaluationMode::ConstantExpression;
+  EvalInfo Info(Ctx, /*Sema=*/nullptr, Result, EM);
 
-  EvalInfo Info(Ctx, EStatus,
-                (IsConstantInitialization &&
-                 (Ctx.getLangOpts().CPlusPlus || Ctx.getLangOpts().C23))
-                    ? EvaluationMode::ConstantExpression
-                    : EvaluationMode::ConstantFold);
-  Info.setEvaluatingDecl(VD, EStatus.Val);
-  Info.InConstantContext = IsConstantInitialization;
+  return ::EvaluateConstantExpr(Result, Ctx, Info, this, Kind);
+}
+
+bool Expr::EvaluateAsMandatedConstantExpr(EvalResult &Result,
----------------
katzdm wrote:

I don't think that this is meaningfully more code duplication than occurs between other entry-points into the constant evaluator (e.g., `EvaluateAsInitializer`, `EvaluateAsRValue`, `EvaluateAsConstantExpr`, etc): They all assert against value-dependence; they all instantiate a `TimeScope`; they all construct the `EvalInfo`. I think the level of code duplication is relatively low, and fits within that established pattern. Let me know if you buy that.

https://github.com/llvm/llvm-project/pull/205557