[clang][ExprConst] Don't create useless temporary variable

[tbaederr]

We never use it anyway.

This code has been introduced in
410306b, but it didn't really do anything back then either, as far as I can tell.

Fixes #57135

[llvmbot]

@llvm/pr-subscribers-clang

Changes

We never use it anyway.

This code has been introduced in
410306b, but it didn't really do anything back then either, as far as I can tell.

Fixes #57135

---

Full diff: https://github.com/llvm/llvm-project/pull/67716.diff

1 Files Affected:

• (modified) clang/lib/AST/ExprConstant.cpp (+2-10)

diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index fea06b97259fe31..04a751f1b4d09fb 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -10950,16 +10950,8 @@ bool ArrayExprEvaluator::VisitCXXParenListOrInitListExpr(
 }
 
 bool ArrayExprEvaluator::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
-  LValue CommonLV;
-  if (E->getCommonExpr() &&
-      !Evaluate(Info.CurrentCall->createTemporary(
-                    E->getCommonExpr(),
-                    getStorageType(Info.Ctx, E->getCommonExpr()),
-                    ScopeKind::FullExpression, CommonLV),
-                Info, E->getCommonExpr()->getSourceExpr()))
-    return false;
-
-  auto *CAT = cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe());
+  const auto *CAT =
+      cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe());
 
   uint64_t Elements = CAT->getSize().getZExtValue();
   Result = APValue(APValue::UninitArray(), Elements, Elements);

[zygoloid]

The semantics of ArrayInitLoopExpr are to first evaluate (once, up-front) the common expression, and then evaluate the subexpression once for each array element, where the subexpression can make repeated reference to the value of the common expression. With this change, we will instead evaluate the common expression once for each iteration of the loop. I would expect this change will cause us to miscompile this example:

struct X {
    int arr[3];
};
constexpr X f(int &r) {
    return {++r, ++r, ++r};
}
constexpr int g() {
    int n = 0;
    auto [a, b, c] = f(n).arr;
    return a + b + c;
}
static_assert(g() == 6)

... because we'll interpret the initializer of [a, b, c] as {f(n).arr[0], f(n).arr[1], f(n).arr[2]} instead of as <common> = f(n).arr; {<common>[0], <common>[1], <common>[2]}.

[tbaederr]

Ah, didn't realize that. We should have a test case for this.