clang-format: [JS] for async loops.

[mprobst]

Summary

JavaScript supports asynchronous loop iteration in async functions:

for async (const x of y) ...

[djasper]

lib/Format/TokenAnnotator.cpp

583 ↗

(On Diff #98996)

Can we make this JS specific, e.g. by turning l. 579 into:

if (Style.Language == FormatStyle::LK_JavaScript) {
  if (Tok->Previous && Tok->Previous->is(tok::period))
    break;
  if (CurrentToken->is(Keywords.kw_async))
    next();
}

Alternatively, leave a comment that this is JavaScript's "async"

lib/Format/UnwrappedLineParser.cpp

1638 ↗

(On Diff #98996)

Same here.. Make this JS specific or at least leave a comment.

[mprobst]

• make parsing JS specific

[mprobst]

lib/Format/TokenAnnotator.cpp

583 ↗

(On Diff #98996)

My reasoning was that this would at best be a syntax error in other languages, so it's fine to parse. But changed to be JS specific, that might be cleaner.

cfe/trunk/lib/Format/TokenAnnotator.cpp

bool consumeToken() {
     case tok::kw_while:
       if (CurrentToken && CurrentToken->is(tok::l_paren)) {
         next();
         if (!parseParens(/*LookForDecls=*/true))
           return false;
       }
       break;
     case tok::kw_for:
-      if (Style.Language == FormatStyle::LK_JavaScript && Tok->Previous &&
-          Tok->Previous->is(tok::period))
+      if (Style.Language == FormatStyle::LK_JavaScript)
+        if (Tok->Previous && Tok->Previous->is(tok::period))
           break;
+        // JS' for async ( ...
+        if (CurrentToken->is(Keywords.kw_async))
+          next();
       Contexts.back().ColonIsForRangeExpr = true;
       next();
       if (!parseParens())
         return false;
       break;
     case tok::l_paren:
       // When faced with 'operator()()', the kw_operator handler incorrectly
       // marks the first l_paren as a OverloadedOperatorLParen. Here, we make
if (Right.is(tok::period) &&
                      Keywords.kw_repeated, Keywords.kw_extend))
       return true;
     if (Right.is(tok::l_paren) &&
         Left.isOneOf(Keywords.kw_returns, Keywords.kw_option))
       return true;
   } else if (Style.Language == FormatStyle::LK_JavaScript) {
     if (Left.is(TT_JsFatArrow))
       return true;
+    // for async ( ...
+    if (Right.is(tok::l_paren) && Left.is(Keywords.kw_async) &&
+        Left.Previous && Left.Previous->is(tok::kw_for))
+      return true;
     if (Left.is(Keywords.kw_async) && Right.is(tok::l_paren) &&
         Right.MatchingParen) {
       const FormatToken *Next = Right.MatchingParen->getNextNonComment();
       // An async arrow function, for example: `x = async () => foo();`,
       // as opposed to calling a function called async: `x = async();`
       if (Next && Next->is(TT_JsFatArrow))
         return true;
     }

cfe/trunk/lib/Format/UnwrappedLineParser.cpp

do {
     nextToken();
   } while (!eof());
 }
 
 void UnwrappedLineParser::parseForOrWhileLoop() {
   assert(FormatTok->isOneOf(tok::kw_for, tok::kw_while, TT_ForEachMacro) &&
          "'for', 'while' or foreach macro expected");
   nextToken();
+  // JS' for async ( ...
+  if (Style.Language == FormatStyle::LK_JavaScript &&
+      FormatTok->is(Keywords.kw_async))
+    nextToken();
   if (FormatTok->Tok.is(tok::l_paren))
     parseParens();
   if (FormatTok->Tok.is(tok::l_brace)) {
     CompoundStatementIndenter Indenter(this, Style, Line->Level);
     parseBlock(/*MustBeDeclaration=*/false);
     addUnwrappedLine();
   } else {
     addUnwrappedLine();

cfe/trunk/unittests/Format/FormatTestJS.cpp

verifyFormat("class X {\n"
                "  async asyncMethod() {\n"
                "    return fetch(1);\n"
                "  }\n"
                "}");
   verifyFormat("function initialize() {\n"
                "  // Comment.\n"
                "  return async.then();\n"
                "}\n");
+  verifyFormat("for async (const x of y) {\n"
+               "  console.log(x);\n"
+               "}\n");
+  verifyFormat("function asyncLoop() {\n"
+               "  for async (const x of y) {\n"
+               "    console.log(x);\n"
+               "  }\n"
+               "}\n");
+
 }
 
 TEST_F(FormatTestJS, FunctionParametersTrailingComma) {
   verifyFormat("function trailingComma(\n"
                "    p1,\n"
                "    p2,\n"
                "    p3,\n"
                ") {\n"