Support GNU extension StmtExpr in constexpr function

[sberg]

Summary

The assert.h in glibc 2.25 defines assert as a GNU-extension "statement expression", see https://sourceware.org/git/?p=glibc.git;a=commit;h=e077349ce589466eecd47213db4fae6b80ec18c4 "assert.h: allow gcc to detect assert(a = 1) errors". That caused Clang's -std=gnu++14 to no longer treat constexpr functions containing assert as actually being constant expressions. (And I ran into that when trying to build LibreOffice master with Clang trunk against Fedora 26 glibc.)

[sberg]

(the original diff had inadvertently lacked full -U999999 context; uploaded a new diff)

clang/lib/AST/ExprConstant.cpp

bool VisitStmtExpr(const StmtExpr *E) {
 
     BlockScopeRAII Scope(Info);
     const CompoundStmt *CS = E->getSubStmt();
     if (CS->body_empty())
       return true;
 
     for (CompoundStmt::const_body_iterator BI = CS->body_begin(),
                                            BE = CS->body_end();
-         /**/; ++BI) {
-      if (BI + 1 == BE) {
-        const Expr *FinalExpr = dyn_cast<Expr>(*BI);
-        if (!FinalExpr) {
-          Info.FFDiag((*BI)->getLocStart(),
-                    diag::note_constexpr_stmt_expr_unsupported);
-          return false;
-        }
+         BI != BE; ++BI) {
+      if (BI + 1 == BE)
+        if (const Expr *FinalExpr = dyn_cast<Expr>(*BI))
           return this->Visit(FinalExpr);
-      }
 
       APValue ReturnValue;
       StmtResult Result = { ReturnValue, nullptr };
       EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
       if (ESR != ESR_Succeeded) {
         // FIXME: If the statement-expression terminated due to 'return',
         // 'break', or 'continue', it would be nice to propagate that to
         // the outer statement evaluation rather than bailing out.
         if (ESR != ESR_Failed)
           Info.FFDiag((*BI)->getLocStart(),
                     diag::note_constexpr_stmt_expr_unsupported);
         return false;
       }
     }
 
-    llvm_unreachable("Return from function from the loop above.");
+    return true;
   }
 
   /// Visit a value which is evaluated, but whose value is ignored.
   void VisitIgnoredValue(const Expr *E) {
     EvaluateIgnoredValue(Info, E);
   }
 
   /// Potentially visit a MemberExpr's base expression.

clang/test/SemaCXX/constant-expression-cxx1y.cpp

constexpr int f(int k) {
     }
   }
   static_assert(f(1) == 1, ""); // expected-error {{constant expression}} expected-note {{in call}}
 
   constexpr int g() { // expected-error {{never produces a constant}}
     return ({ int n; n; }); // expected-note {{object of type 'int' is not initialized}}
   }
 
-  // FIXME: We should handle the void statement expression case.
-  constexpr int h() { // expected-error {{never produces a constant}}
-    ({ if (true) {} }); // expected-note {{not supported}}
+  constexpr int h() {
+    ({ if (true) {} });
     return 0;
   }
 }
 
 namespace VirtualFromBase {
   struct S1 {
     virtual int f() const;
   };