[clang] Make clear Sema::CheckForConstantInitializer is for C-only codepath.

[hokein]

Summary

• add an assertion;
• remove the changes introduced in https://github.com/llvm/llvm-project/commit/4a962f03bebef9e3c7d501580357a303638b2700, looks like clang can handle that well at the moment, the diagnostic seems better;

[hokein]

clang/lib/Sema/SemaDecl.cpp

11072

openCL for C++ is tricky, see https://github.com/llvm/llvm-project/blob/master/clang/lib/Sema/SemaDecl.cpp#L12134-L12135.

[hokein]

clang/test/SemaCXX/compound-literal.cpp

92

hmm, clang will crash at CodeGen again if we turn off the -Wuninitialized warning.

[hokein]

clang/lib/Sema/SemaDecl.cpp

11072

actually, I think the code is correct, the above comment is not up-to-date, so we just need to update the comment, see D84145.

clang/lib/Sema/SemaDecl.cpp

bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
   // FIXME: Need strict checking.  In C89, we need to check for
   // any assignment, increment, decrement, function-calls, or
   // commas outside of a sizeof.  In C99, it's the same list,
   // except that the aforementioned are allowed in unevaluated
   // expressions.  Everything else falls under the
   // "may accept other forms of constant expressions" exception.
   // (We never end up here for C++, so the constant expression
   // rules there don't matter.)
+  assert(!getLangOpts().CPlusPlus || getLangOpts().OpenCLCPlusPlus);
   const Expr *Culprit;
   if (Init->isConstantInitializer(Context, false, &Culprit))
     return false;
   Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
     << Culprit->getSourceRange();
   return true;
 }
 

clang/lib/Sema/SemaExpr.cpp

if (isFileScope)
     if (auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
       for (unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
         Expr *Init = ILE->getInit(i);
         ILE->setInit(i, ConstantExpr::Create(Context, Init));
       }
 
   auto *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
                                               VK, LiteralExpr, isFileScope);
-  if (isFileScope) {
-    if (!LiteralExpr->isTypeDependent() &&
-        !LiteralExpr->isValueDependent() &&
-        !literalType->isDependentType()) // C99 6.5.2.5p3
-      if (CheckForConstantInitializer(LiteralExpr, literalType))
-        return ExprError();
+  if (isFileScope && !getLangOpts().CPlusPlus) { // C99 6.5.2.5p3
   } else if (literalType.getAddressSpace() != LangAS::opencl_private &&
              literalType.getAddressSpace() != LangAS::Default) {
     // Embedded-C extensions to C99 6.5.2.5:
     //   "If the compound literal occurs inside the body of a function, the
     //   type name shall not be qualified by an address-space qualifier."
     Diag(LParenLoc, diag::err_compound_literal_with_address_space)
       << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
     return ExprError();

clang/test/SemaCXX/compound-literal.cpp

private:
     ~PrivateDtor(); // expected-note {{declared private here}}
   };
 
   void testPrivateDtor() {
     (void)(PrivateDtor){1, 2}; // expected-error {{temporary of type 'brace_initializers::PrivateDtor' has private destructor}}
   }
 }
 
-// This doesn't necessarily need to be an error, but CodeGen can't handle it
-// at the moment.
-int PR17415 = (int){PR17415}; // expected-error {{initializer element is not a compile-time constant}}
+int PR17415 = (int){PR17415}; // expected-warning {{variable 'PR17415' is uninitialized when used within its own initialization}}
 
 // Make sure we accept this.  (Not sure if we actually should... but we do
 // at the moment.)
 template<unsigned> struct Value { };
 template<typename T>
 int &check_narrowed(Value<sizeof((T){1.1})>);
 
 #if __cplusplus >= 201103L
 // Compound literals in global lambdas have automatic storage duration
 // and are not subject to the constant-initialization rules.
 int computed_with_lambda = [] {
   int x = 5;
   int result = ((int[]) { x, x + 2, x + 4, x + 6 })[0];
   return result;
 }();
 #endif