Add async component syntax support

Summary:
Add `async component` syntax support to the Hermes C++ parser, hermes-parser JS package, and all associated tests.

AST: Add `async` boolean field (default false) to `ComponentDeclaration` nodes in ESTree.def.

Parser: Add `checkAsyncComponentFlow()` lookahead, update `parseDeclaration()` and export handlers to recognize `async component` variants. The `parseComponentDeclarationFlow` function gains an `isAsync` parameter. `declare async component` is rejected with a parse error directing users to use `declare component` instead.

Updates all existing component syntax FileCheck tests for consistency. Adds new tests for async component. Updates hermes-parser JS tests and snapshots. Updates flowtest tree.json snapshots for consistency.

Reviewed By: avp

Differential Revision: D93299448

fbshipit-source-id: 0f17df8c8860831538b50feff704a3751e330e57

Author: mvitousek

include/hermes/AST/ESTree.def

@@ -77,13 +77,14 @@ ESTREE_IGNORE_IF_EMPTY(FunctionDeclaration, predicate)
 
 #if HERMES_PARSE_FLOW
 
-ESTREE_NODE_5_ARGS(
+ESTREE_NODE_6_ARGS(
     ComponentDeclaration, FunctionLike,
     NodePtr, id, false,
     NodeList, params, false,
     NodePtr, body, false,
     NodePtr, typeParameters, true,
-    NodePtr, rendersType, true)
+    NodePtr, rendersType, true,
+    NodeBoolean, async, false)
 ESTREE_IGNORE_IF_EMPTY(ComponentDeclaration, typeParameters)
 ESTREE_IGNORE_IF_EMPTY(ComponentDeclaration, rendersType)
 

lib/Parser/JSParserImpl-flow.cpp

@@ -22,6 +22,13 @@ Optional<ESTree::Node *> JSParserImpl::parseFlowDeclaration() {
   assert(checkDeclaration());
   SMLoc start = tok_->getStartLoc();
 
+  if (context_.getParseFlowComponentSyntax() && check(asyncIdent_) &&
+      checkAsyncComponentFlow()) {
+    advance(); // consume 'async'
+    return parseComponentDeclarationFlow(
+        start, /* declare */ false, /* isAsync */ true);
+  }
+
   if (context_.getParseFlowComponentSyntax() &&
       checkComponentDeclarationFlow()) {
     return parseComponentDeclarationFlow(start, /* declare */ false);
@@ -101,6 +108,17 @@ Optional<ESTree::Node *> JSParserImpl::parseDeclareFLow(SMLoc start) {
     return parseDeclareHookFlow(start);
   }
 
+  if (context_.getParseFlowComponentSyntax() && check(asyncIdent_) &&
+      checkAsyncComponentFlow()) {
+    error(
+        tok_->getStartLoc(),
+        "`async` is not supported for declared components. "
+        "Use `declare component` instead.");
+    advance(); // consume 'async'
+    return parseComponentDeclarationFlow(
+        start, /* declare */ true, /* isAsync */ true);
+  }
+
   if (context_.getParseFlowComponentSyntax() &&
       checkComponentDeclarationFlow()) {
     return parseComponentDeclarationFlow(start, /* declare */ true);
@@ -167,9 +185,23 @@ bool JSParserImpl::checkComponentDeclarationFlow() {
   return optNext.hasValue() && *optNext == TokenKind::identifier;
 }
 
+bool JSParserImpl::checkAsyncComponentFlow() {
+  // async [no LineTerminator here] component
+  // ^
+  // Callers must already check check(asyncIdent_).
+  assert(check(asyncIdent_));
+  JSLexer::SavePoint savePoint{&lexer_};
+  advance();
+  bool result =
+      !lexer_.isNewLineBeforeCurrentToken() && checkComponentDeclarationFlow();
+  savePoint.restore();
+  return result;
+}
+
 Optional<ESTree::Node *> JSParserImpl::parseComponentDeclarationFlow(
     SMLoc start,
-    bool declare) {
+    bool declare,
+    bool isAsync) {
   // component
   assert(check(componentIdent_));
   advance();
@@ -247,7 +279,7 @@ Optional<ESTree::Node *> JSParserImpl::parseComponentDeclarationFlow(
   SaveStrictModeAndSeenDirectives saveStrictModeAndSeenDirectives{this};
 
   auto parsedBody = parseFunctionBody(
-      Param{}, false, false, false, JSLexer::AllowRegExp, true);
+      Param{}, false, false, isAsync, JSLexer::AllowRegExp, true);
   if (!parsedBody)
     return None;
   auto *body = parsedBody.getValue();
@@ -256,7 +288,12 @@ Optional<ESTree::Node *> JSParserImpl::parseComponentDeclarationFlow(
       start,
       body,
       new (context_) ESTree::ComponentDeclarationNode(
-          *optId, std::move(paramList), body, typeParams, rendersType));
+          *optId,
+          std::move(paramList),
+          body,
+          typeParams,
+          rendersType,
+          isAsync));
 }
 
 bool JSParserImpl::parseComponentParametersFlow(
@@ -2081,6 +2118,23 @@ Optional<ESTree::Node *> JSParserImpl::parseDeclareExportFlow(SMLoc start) {
           new (context_) ESTree::DeclareExportDeclarationNode(
               *optFunc, {}, nullptr, true));
     }
+    if (context_.getParseFlowComponentSyntax() && check(asyncIdent_) &&
+        checkAsyncComponentFlow()) {
+      error(
+          tok_->getStartLoc(),
+          "`async` is not supported for declared components. "
+          "Use `declare component` instead.");
+      advance(); // consume 'async'
+      auto optComponent = parseComponentDeclarationFlow(
+          start, /* declare */ true, /* isAsync */ true);
+      if (!optComponent)
+        return None;
+      return setLocation(
+          start,
+          *optComponent,
+          new (context_) ESTree::DeclareExportDeclarationNode(
+              *optComponent, {}, nullptr, true));
+    }
     if (context_.getParseFlowComponentSyntax() &&
         checkComponentDeclarationFlow()) {
       auto optComponent =
@@ -2148,6 +2202,24 @@ Optional<ESTree::Node *> JSParserImpl::parseDeclareExportFlow(SMLoc start) {
             *optClass, {}, nullptr, false));
   }
 
+  if (context_.getParseFlowComponentSyntax() && check(asyncIdent_) &&
+      checkAsyncComponentFlow()) {
+    error(
+        tok_->getStartLoc(),
+        "`async` is not supported for declared components. "
+        "Use `declare component` instead.");
+    advance(); // consume 'async'
+    auto optComponent = parseComponentDeclarationFlow(
+        start, /* declare */ true, /* isAsync */ true);
+    if (!optComponent)
+      return None;
+    return setLocation(
+        start,
+        *optComponent,
+        new (context_) ESTree::DeclareExportDeclarationNode(
+            *optComponent, {}, nullptr, false));
+  }
+
   if (context_.getParseFlowComponentSyntax() &&
       checkComponentDeclarationFlow()) {
     auto optComponent =

lib/Parser/JSParserImpl.cpp

@@ -791,7 +791,8 @@ Optional<ESTree::Node *> JSParserImpl::parseDeclaration(Param param) {
 
   assert(checkDeclaration() && "invalid start for declaration");
 
-  if (check(TokenKind::rw_function) || check(asyncIdent_)) {
+  if (check(TokenKind::rw_function) ||
+      (check(asyncIdent_) && checkAsyncFunction())) {
     auto fdecl = parseFunctionDeclaration(Param{});
     if (!fdecl)
       return None;
@@ -6747,6 +6748,19 @@ Optional<ESTree::Node *> JSParserImpl::parseExportDeclaration() {
           *optClassDecl,
           new (context_) ESTree::ExportDefaultDeclarationNode(*optClassDecl));
 #if HERMES_PARSE_FLOW
+    } else if (
+        context_.getParseFlow() && context_.getParseFlowComponentSyntax() &&
+        check(asyncIdent_) && checkAsyncComponentFlow()) {
+      SMLoc compStart = advance().Start;
+      auto optComponent = parseComponentDeclarationFlow(
+          compStart, /* declare */ false, /* isAsync */ true);
+      if (!optComponent) {
+        return None;
+      }
+      return setLocation(
+          startLoc,
+          *optComponent,
+          new (context_) ESTree::ExportDefaultDeclarationNode(*optComponent));
     } else if (
         context_.getParseFlow() && context_.getParseFlowComponentSyntax() &&
         checkComponentDeclarationFlow()) {

lib/Parser/JSParserImpl.h

@@ -539,7 +539,8 @@ class JSParserImpl {
 #if HERMES_PARSE_FLOW
     if (context_.getParseFlow()) {
       if (context_.getParseFlowComponentSyntax() &&
-          checkComponentDeclarationFlow()) {
+          (checkComponentDeclarationFlow() ||
+           (check(asyncIdent_) && checkAsyncComponentFlow()))) {
         return true;
       }
       if (context_.getParseFlowComponentSyntax() &&
@@ -1184,9 +1185,11 @@ class JSParserImpl {
   Optional<ESTree::Node *> parseFlowDeclaration();
   Optional<ESTree::Node *> parseDeclareFLow(SMLoc start);
   bool checkComponentDeclarationFlow();
+  bool checkAsyncComponentFlow();
   Optional<ESTree::Node *> parseComponentDeclarationFlow(
       SMLoc start,
-      bool declare);
+      bool declare,
+      bool isAsync = false);
   bool checkHookDeclarationFlow();
   Optional<ESTree::Node *> parseHookDeclarationFlow(SMLoc start);