Allow C11 static assert declaration as clause-1 in for loops.

[rcraik]

Summary

According to the C11 standard, _Static_assert should be allowed as clause-1 in a for loop.

For example:

for (_Static_assert(1, "1 is nonzero");;) {}

The relevant section of the C11 grammar is:
for ( declaration expressionopt ; expressionopt ) statement
declaration:
declaration-specifiers init-declarator-listopt ;
static_assert-declaration

It is not allowed in C++11, where the for statement has the form:
for ( for-init-statement conditionopt; expressionopt) statement
and for-init-statement can only be an expression-statement or a simple-declaration, not a static_assert-declaration

[rsmith]

This seems much more likely to be a defect in C11 than a deliberate feature to me. Have you asked WG14 whether this was intentional?

[rcraik]

In D9113#158676, @rsmith wrote:

This seems much more likely to be a defect in C11 than a deliberate feature to me. Have you asked WG14 whether this was intentional?

I asked the question and the consensus seems to be that it should not be allowed. The relevant thread is www.open-std.org/JTC1/SC22/WG14/13677

[rsmith]

Thanks, then I think we can put this on hold for now. We can revisit it if the C committee decide that they do in fact want to allow this. (I also agree with one of the comments there, that the current wording can be read as saying that this is not allowed because a _Static_assert declaration declares something other than an identifier.)

include/clang/Parse/Parser.h

bool isDeclarationStatement() {
     if (getLangOpts().CPlusPlus)
       return isCXXDeclarationStatement();
     return isDeclarationSpecifier(true);
   }
 
   /// isForInitDeclaration - Disambiguates between a declaration or an
   /// expression in the context of the C 'clause-1' or the C++
   // 'for-init-statement' part of a 'for' statement.
-  /// Returns true for declaration, false for expression.
+  /// Returns true for C declaration or C++ simple-declaration, false otherwise
   bool isForInitDeclaration() {
     if (getLangOpts().CPlusPlus)
       return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/true);
     return isDeclarationSpecifier(true);
   }
 
   /// \brief Determine whether this is a C++1z for-range-identifier.
   bool isForRangeIdentifier();
Decl *ParseUsingDirective(unsigned Context,
                             SourceLocation &DeclEnd,
                             ParsedAttributes &attrs);
   Decl *ParseUsingDeclaration(unsigned Context,
                               const ParsedTemplateInfo &TemplateInfo,
                               SourceLocation UsingLoc,
                               SourceLocation &DeclEnd,
                               AccessSpecifier AS = AS_none,
                               Decl **OwnedType = nullptr);
-  Decl *ParseStaticAssertDeclaration(SourceLocation &DeclEnd);
+  Decl *ParseStaticAssertDeclaration(SourceLocation &DeclEnd,
+                                     bool RequireSemi = true);
   Decl *ParseNamespaceAlias(SourceLocation NamespaceLoc,
                             SourceLocation AliasLoc, IdentifierInfo *Alias,
                             SourceLocation &DeclEnd);
 
   //===--------------------------------------------------------------------===//
   // C++ 9: classes [class] and C structs/unions.
   bool isValidAfterTypeSpecifier(bool CouldBeBitfield);
   void ParseClassSpecifier(tok::TokenKind TagTokKind, SourceLocation TagLoc,

lib/Parse/ParseDeclCXX.cpp

 /// ParseStaticAssertDeclaration - Parse C++0x or C11 static_assert-declaration.
 ///
 /// [C++0x] static_assert-declaration:
 ///           static_assert ( constant-expression  ,  string-literal  ) ;
 ///
 /// [C11]   static_assert-declaration:
 ///           _Static_assert ( constant-expression  ,  string-literal  ) ;
 ///
-Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){
+Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd,
+                                           bool RequireSemi) {
   assert((Tok.is(tok::kw_static_assert) || Tok.is(tok::kw__Static_assert)) &&
          "Not a static_assert declaration");
 
   if (Tok.is(tok::kw__Static_assert) && !getLangOpts().C11)
     Diag(Tok, diag::ext_c11_static_assert);
   if (Tok.is(tok::kw_static_assert))
     Diag(Tok, diag::warn_cxx98_compat_static_assert);
 
if (AssertMessage.isInvalid()) {
       SkipMalformedDecl();
       return nullptr;
     }
   }
 
   T.consumeClose();
 
   DeclEnd = Tok.getLocation();
+  if (RequireSemi)
     ExpectAndConsumeSemi(diag::err_expected_semi_after_static_assert);
 
   return Actions.ActOnStaticAssertDeclaration(StaticAssertLoc,
                                               AssertExpr.get(),
                                               AssertMessage.get(),
                                               T.getCloseLocation());
 }
 
 /// ParseDecltypeSpecifier - Parse a C++11 decltype specifier.

lib/Parse/ParseStmt.cpp

if (Tok.is(tok::semi)) {  // for (;
     if (!C99orCXXorObjC)   // Use of C99-style for loops in C90 mode?
       Diag(Tok, diag::ext_c99_variable_decl_in_for_loop);
 
     // In C++0x, "for (T NS:a" might not be a typo for ::
     bool MightBeForRangeStmt = getLangOpts().CPlusPlus;
     ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt);
 
     SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
-    DeclGroupPtrTy DG = ParseSimpleDeclaration(
+    DeclGroupPtrTy DG;
+    // in C11, the declaration may be a static_assert-declaration
+    if (Tok.is(tok::kw__Static_assert)) {
+      ProhibitAttributes(attrs);
+      DG = Actions.ConvertDeclToDeclGroup(
+          ParseStaticAssertDeclaration(DeclEnd, false));
+    } else {
+      DG = ParseSimpleDeclaration(
           Declarator::ForContext, DeclEnd, attrs, false,
           MightBeForRangeStmt ? &ForRangeInit : nullptr);
+    }
     FirstPart = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
     if (ForRangeInit.ParsedForRangeDecl()) {
       Diag(ForRangeInit.ColonLoc, getLangOpts().CPlusPlus11 ?
            diag::warn_cxx98_compat_for_range : diag::ext_for_range);
 
       ForRange = true;
     } else if (Tok.is(tok::semi)) {  // for (int x = 4;
       ConsumeToken();

lib/Sema/SemaStmt.cpp

Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
                    FullExprArg third,
                    SourceLocation RParenLoc, Stmt *Body) {
   if (!getLangOpts().CPlusPlus) {
     if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
       // C99 6.8.5p3: The declaration part of a 'for' statement shall only
       // declare identifiers for objects having storage class 'auto' or
       // 'register'.
       for (auto *DI : DS->decls()) {
+        // C11: skip over static assertions
+        if (isa<StaticAssertDecl>(DI))
+          continue;
         VarDecl *VD = dyn_cast<VarDecl>(DI);
         if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
           VD = nullptr;
         if (!VD) {
           Diag(DI->getLocation(), diag::err_non_local_variable_decl_in_for);
           DI->setInvalidDecl();
         }
       }

test/Parser/static-assert.c

+// RUN: %clang_cc1 -std=c11 -fsyntax-only -verify %s
+
+void f() {
+  for (_Static_assert(1, "1 is nonzero");;) {}
+  for (_Static_assert(0, "0 is nonzero");;) {} // expected-error {{static_assert failed "0 is nonzero"}}
+}

test/Parser/static-assert.cpp

+// RUN: %clang_cc1 -xc++ -std=c++11 -fsyntax-only -verify %s
+
+void f() {
+  for (static_assert(1, "1 is nonzero");;) {} // expected-error {{expected expression}}
+  for (static_assert(0, "0 is nonzero");;) {} // expected-error {{expected expression}}
+}