[es7] Implement async functions parsing

src/preparser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 30 matching lines @@
     return PreParserIdentifier::FutureReserved();
   } else if (scanner->current_token() ==
              Token::FUTURE_STRICT_RESERVED_WORD) {
     return PreParserIdentifier::FutureStrictReserved();
   } else if (scanner->current_token() == Token::LET) {
     return PreParserIdentifier::Let();
   } else if (scanner->current_token() == Token::STATIC) {
     return PreParserIdentifier::Static();
   } else if (scanner->current_token() == Token::YIELD) {
     return PreParserIdentifier::Yield();
+  } else if (scanner->current_token() == Token::ASYNC) {
+    return PreParserIdentifier::Async();
   }
   if (scanner->UnescapedLiteralMatches("eval", 4)) {
     return PreParserIdentifier::Eval();
   }
   if (scanner->UnescapedLiteralMatches("arguments", 9)) {
     return PreParserIdentifier::Arguments();
   }
   if (scanner->UnescapedLiteralMatches("undefined", 9)) {
     return PreParserIdentifier::Undefined();
   }
@@ skipping 122 matching lines @@
   // HoistableDeclaration[Yield, Default] :
   //   FunctionDeclaration[?Yield, ?Default]
   //   GeneratorDeclaration[?Yield, ?Default]
   //
   // LexicalDeclaration[In, Yield] :
   //   LetOrConst BindingList[?In, ?Yield] ;
 
   switch (peek()) {
     case Token::FUNCTION:
       return ParseFunctionDeclaration(ok);
+    case Token::ASYNC:
+      if (IsNextAsyncFunctionKeyword()) {
+        return ParseFunctionDeclaration(ok);
+      }
+      break;
     case Token::CLASS:
       return ParseClassDeclaration(ok);
     case Token::CONST:
       if (allow_const()) {
         return ParseVariableStatement(kStatementListItem, ok);
       }
       break;
     case Token::LET:
       if (IsNextLetKeyword()) {
         return ParseVariableStatement(kStatementListItem, ok);
@@ skipping 187 matching lines @@
 
     case Token::SWITCH:
       return ParseSwitchStatement(ok);
 
     case Token::THROW:
       return ParseThrowStatement(ok);
 
     case Token::TRY:
       return ParseTryStatement(ok);
 
+    case Token::ASYNC:
+      // Make sure async keyword is followed by a function keyword,
+      // otherwise parse 'async' as part of an expression or
+      // labelled statement (default case in this switch).
+      if (!allow_harmony_async_await() || !IsNextAsyncFunctionKeyword()) {
+        return ParseExpressionOrLabelledStatement(ok);
+      }
+
+    // Fall through.
     case Token::FUNCTION: {
       Scanner::Location start_location = scanner()->peek_location();
       Statement statement = ParseFunctionDeclaration(CHECK_OK);
       Scanner::Location end_location = scanner()->location();
       if (is_strict(language_mode())) {
         PreParserTraits::ReportMessageAt(start_location.beg_pos,
                                          end_location.end_pos,
                                          MessageTemplate::kStrictFunction);
         *ok = false;
         return Statement::Default();
@@ skipping 19 matching lines @@
     // Fall through.
     default:
       return ParseExpressionOrLabelledStatement(ok);
   }
 }
 
 
 PreParser::Statement PreParser::ParseFunctionDeclaration(bool* ok) {
   // FunctionDeclaration ::
   //   'function' Identifier '(' FormalParameterListopt ')' '{' FunctionBody '}'
+  // AsyncFunctionDeclaration ::
+  //   'async' 'function' Identifier '(' FormalParameterListopt ')'
+  //      '{' FunctionBody '}'
   // GeneratorDeclaration ::
   //   'function' '*' Identifier '(' FormalParameterListopt ')'
   //      '{' FunctionBody '}'
+  bool is_async = allow_harmony_async_await() ? Check(Token::ASYNC) : false;
   Expect(Token::FUNCTION, CHECK_OK);
   int pos = position();
-  bool is_generator = Check(Token::MUL);
+  bool is_generator = is_async ? false : Check(Token::MUL);
   bool is_strict_reserved = false;
   Identifier name = ParseIdentifierOrStrictReservedWord(
       &is_strict_reserved, CHECK_OK);
+
+  FunctionKind kind = FunctionKind::kNormalFunction;
+  if (is_generator) {
+    kind = FunctionKind::kGeneratorFunction;
+  } else if (is_async) {
+    kind = FunctionKind::kAsyncFunction;
+  }
+
   ParseFunctionLiteral(name, scanner()->location(),
                        is_strict_reserved ? kFunctionNameIsStrictReserved
                                           : kFunctionNameValidityUnknown,
-                       is_generator ? FunctionKind::kGeneratorFunction
-                                    : FunctionKind::kNormalFunction,
-                       pos, FunctionLiteral::DECLARATION,
+                       kind, pos, FunctionLiteral::DECLARATION,
                        FunctionLiteral::NORMAL_ARITY, language_mode(),
                        CHECK_OK);
   return Statement::FunctionDeclaration();
 }
 
 
 PreParser::Statement PreParser::ParseClassDeclaration(bool* ok) {
   Expect(Token::CLASS, CHECK_OK);
   if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
     ReportMessage(MessageTemplate::kSloppyLexical);
@@ skipping 790 matching lines @@
     Expect(Token::RBRACE, CHECK_OK);
     return PreParserExpression::Default();
   }
 }
 
 #undef CHECK_OK
 
 
 }  // namespace internal
 }  // namespace v8