[ExprConstant] Unify handling of array init with lvalues.

[efriedma]

Summary

This should have no functional effect; evaluation is still generating the same result. But the assertions and comments should make it more clear what's actually happening. Part of a fix to https://bugs.llvm.org/show_bug.cgi?id=40430.

It's possible that instead of doing this, we should fix the AST so we don't have "lvalues" which aren't really lvalues.

[efriedma]

I'm now convinced this is the wrong approach.

lib/AST/ExprConstant.cpp

if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
       // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the
       // initializer until now for such expressions. Such an expression can't be
       // an ICE in C, so this only matters for fold.
       if (Type.isVolatileQualified()) {
         Info.FFDiag(Conv);
         return false;
       }
       APValue Lit;
-      if (!Evaluate(Lit, Info, CLE->getInitializer()))
+      if (!EvaluateInPlace(Lit, Info, LVal, CLE->getInitializer()))
         return false;
       CompleteObject LitObj(&Lit, Base->getType(), false);
       return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal);
     } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {
       // We represent a string literal array as an lvalue pointing at the
       // corresponding expression, rather than building an array of chars.
       // FIXME: Support ObjCEncodeExpr, MakeStringConstant
       APValue Str(Base, CharUnits::Zero(), APValue::NoLValuePath(), 0);
case CK_LValueBitCast:
       return true;
 
     case CK_BaseToDerived:
       if (!Visit(E->getSubExpr()))
         return false;
       return HandleBaseToDerivedCast(Info, E, Result);
     }
   }
+  bool VisitInitListExpr(const InitListExpr *E) {
+    // Initialization for string literals should go through EvaluateInPlace.
+    assert(!E->isStringLiteralInit());
+    return LValueExprEvaluatorBaseTy::VisitInitListExpr(E);
+  }
 };
 } // end anonymous namespace
 
 /// Evaluate an expression as an lvalue. This can be legitimately called on
 /// expressions which are not glvalues, in three cases:
 ///  * function designators in C, and
 ///  * "extern void" objects
 ///  * @selector() expressions in Objective-C
bool VisitCallExpr(const CallExpr *E) {
       return handleCallExpr(E, Result, &This);
     }
     bool VisitInitListExpr(const InitListExpr *E);
     bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
     bool VisitCXXConstructExpr(const CXXConstructExpr *E);
     bool VisitCXXConstructExpr(const CXXConstructExpr *E,
                                const LValue &Subobject,
                                APValue *Value, QualType Type);
+    bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
+      // Compound literals are always lvalues in C.
+      assert(Info.getLangOpts().CPlusPlus && "Unexpected compound literal");
+      return EvaluateInPlace(Result, Info, This, E->getInitializer());
+    }
   };
 } // end anonymous namespace
 
 static bool EvaluateArray(const Expr *E, const LValue &This,
                           APValue &Result, EvalInfo &Info) {
   assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue");
   return ArrayExprEvaluator(Info, This, Result).Visit(E);
 }
static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
   return true;
 }
 
 bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
   const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(E->getType());
   if (!CAT)
     return Error(E);
 
-  // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...]
-  // an appropriately-typed string literal enclosed in braces.
   if (E->isStringLiteralInit()) {
-    LValue LV;
-    if (!EvaluateLValue(E->getInit(0), LV, Info))
-      return false;
-    APValue Val;
-    LV.moveInto(Val);
-    return Success(Val, E);
+    // In C++11 mode, init lists for string literal inits are lvalues.
+    assert(!Info.getLangOpts().CPlusPlus11 && "Unexpected init list");
+    return EvaluateInPlace(Result, Info, This, E->getInit(0));
   }
 
   bool Success = true;
 
   assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) &&
          "zero-initialized array shouldn't have any initialized elts");
   APValue Filler;
   if (Result.isArray() && Result.hasArrayFiller())
else if (T->isRecordType())
       return EvaluateRecord(E, This, Result, Info);
     else if (T->isAtomicType()) {
       QualType Unqual = T.getAtomicUnqualifiedType();
       if (Unqual->isArrayType() || Unqual->isRecordType())
         return EvaluateAtomic(E, &This, Result, Info);
     }
   }
 
+  if (This.getLValueDesignator().MostDerivedType->isArrayType()) {
+    // We're initializing a value with "lvalue" array.  It isn't really
+    // an lvalue, though. There are a few ways to land in this situation,
+    // currently:
+    //
+    // 1. String literal initialization ([dcl.init.string]).
+    // 2. @encode literal initialization (essentially the same as string
+    // literal initialization).
+    // 3. The GNU compound literal initialization extension:
+    // "char x[] = (char[]){0}". (Only allowed in C.)
+    //
+    // Bail out for now if we see a compound literal.
+    if (auto *CLE = dyn_cast<CompoundLiteralExpr>(E->IgnoreParens()))
+      return false;
+    // Otherwise, we have some sort of literal we can evaluate as a
+    // constant array.
+    assert(isa<StringLiteral>(E->IgnoreParens()) ||
+           isa<ObjCEncodeExpr>(E->IgnoreParens()) ||
+           isa<InitListExpr>(E->IgnoreParens()));
+    LValue LV;
+    if (!EvaluateLValue(E, LV, Info))
+      llvm_unreachable("String literal init can't fail");
+
+    // Semantically, we should convert the LValue into an array, but currently
+    // we skip that step, and expect users to convert if necessary.
+    LV.moveInto(Result);
+    return true;
+  }
+
   // For any other type, in-place evaluation is unimportant.
   return Evaluate(Result, Info, E);
 }
 
 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
 /// lvalue-to-rvalue cast if it is an lvalue.
 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
   if (E->getType().isNull())