[esnext] implement frontend changes for async/await proposal

src/parsing/preparser.h

 // Copyright 2012 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.
 
 #ifndef V8_PARSING_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 40 matching lines @@
   }
   static PreParserIdentifier Prototype() {
     return PreParserIdentifier(kPrototypeIdentifier);
   }
   static PreParserIdentifier Constructor() {
     return PreParserIdentifier(kConstructorIdentifier);
   }
   static PreParserIdentifier Enum() {
     return PreParserIdentifier(kEnumIdentifier);
   }
+  static PreParserIdentifier Async() {
+    return PreParserIdentifier(kAsyncIdentifier);
+  }
   static PreParserIdentifier Await() {
     return PreParserIdentifier(kAwaitIdentifier);
   }
   bool IsEval() const { return type_ == kEvalIdentifier; }
   bool IsArguments() const { return type_ == kArgumentsIdentifier; }
   bool IsEvalOrArguments() const { return IsEval() || IsArguments(); }
   bool IsUndefined() const { return type_ == kUndefinedIdentifier; }
   bool IsLet() const { return type_ == kLetIdentifier; }
   bool IsStatic() const { return type_ == kStaticIdentifier; }
   bool IsYield() const { return type_ == kYieldIdentifier; }
   bool IsPrototype() const { return type_ == kPrototypeIdentifier; }
   bool IsConstructor() const { return type_ == kConstructorIdentifier; }
   bool IsEnum() const { return type_ == kEnumIdentifier; }
+  bool IsFutureReserved() const {
+    // TODO(caitp): include `kAwaitIdentifier` when parsing a Module
+    return type_ == kFutureReservedIdentifier;
+  }
+  bool IsAsync() const { return type_ == kAsyncIdentifier; }
   bool IsAwait() const { return type_ == kAwaitIdentifier; }
   bool IsFutureStrictReserved() const {
     return type_ == kFutureStrictReservedIdentifier ||
            type_ == kLetIdentifier || type_ == kStaticIdentifier ||
            type_ == kYieldIdentifier;
   }
 
   // Allow identifier->name()[->length()] to work. The preparser
   // does not need the actual positions/lengths of the identifiers.
   const PreParserIdentifier* operator->() const { return this; }
   const PreParserIdentifier raw_name() const { return *this; }
 
   int position() const { return 0; }
   int length() const { return 0; }
 
  private:
   enum Type {
     kUnknownIdentifier,
     kFutureReservedIdentifier,
     kFutureStrictReservedIdentifier,
     kLetIdentifier,
     kStaticIdentifier,
     kYieldIdentifier,
     kEvalIdentifier,
     kArgumentsIdentifier,
     kUndefinedIdentifier,
     kPrototypeIdentifier,
     kConstructorIdentifier,
     kEnumIdentifier,
+    kAsyncIdentifier,
     kAwaitIdentifier
   };
 
   explicit PreParserIdentifier(Type type) : type_(type) {}
   Type type_;
 
   friend class PreParserExpression;
 };
 
 
@@ skipping 486 matching lines @@
 
   // Helper functions for recursive descent.
   static bool IsEval(PreParserIdentifier identifier) {
     return identifier.IsEval();
   }
 
   static bool IsArguments(PreParserIdentifier identifier) {
     return identifier.IsArguments();
   }
 
+  static bool IsAsync(PreParserIdentifier identifier) {
+    return identifier.IsAsync();
+  }
+
+  static bool IsAwait(PreParserIdentifier identifier) {
+    return identifier.IsAwait();
+  }
+
   static bool IsEvalOrArguments(PreParserIdentifier identifier) {
     return identifier.IsEvalOrArguments();
   }
 
   static bool IsUndefined(PreParserIdentifier identifier) {
     return identifier.IsUndefined();
   }
 
   static bool IsPrototype(PreParserIdentifier identifier) {
     return identifier.IsPrototype();
@@ skipping 215 matching lines @@
   V8_INLINE PreParserStatementList ParseEagerFunctionBody(
       PreParserIdentifier function_name, int pos,
       const PreParserFormalParameters& parameters, FunctionKind kind,
       FunctionLiteral::FunctionType function_type, bool* ok);
 
   V8_INLINE void ParseArrowFunctionFormalParameterList(
       PreParserFormalParameters* parameters,
       PreParserExpression expression, const Scanner::Location& params_loc,
       Scanner::Location* duplicate_loc, bool* ok);
 
+  V8_INLINE PreParserExpression ParseAsyncFunctionExpression(bool* ok);
+
   void ReindexLiterals(const PreParserFormalParameters& paramaters) {}
 
   struct TemplateLiteralState {};
 
   TemplateLiteralState OpenTemplateLiteral(int pos) {
     return TemplateLiteralState();
   }
   void AddTemplateSpan(TemplateLiteralState*, bool) {}
   void AddTemplateExpression(TemplateLiteralState*, PreParserExpression) {}
   PreParserExpression CloseTemplateLiteral(TemplateLiteralState*, int,
@@ skipping 52 matching lines @@
 
   inline void MaterializeUnspreadArgumentsLiterals(int count);
 
   inline PreParserExpression SpreadCall(PreParserExpression function,
                                         PreParserExpressionList args, int pos);
 
   inline PreParserExpression SpreadCallNew(PreParserExpression function,
                                            PreParserExpressionList args,
                                            int pos);
 
+  inline PreParserExpression ExpressionListToExpression(
+      PreParserExpressionList args) {
+    return PreParserExpression::Default();

[Dan Ehrenberg, 2016/05/05 01:14:40]

When do you accumulate these to a classifier/validate arrow function formal
parameters/ban await?

[caitp (gmail), 2016/05/05 01:36:57]

The main use of this is to be able to translate `async(FormalParameters) => ...`
into arrow formal parameters --- but classifier errors are recorded during
ParseArguments(), AFAIK if we see it is actually an arrow function, we report
the error.

+  }
+
   inline void RewriteDestructuringAssignments() {}
 
   inline PreParserExpression RewriteExponentiation(PreParserExpression left,
                                                    PreParserExpression right,
                                                    int pos) {
     return left;
   }
   inline PreParserExpression RewriteAssignExponentiation(
       PreParserExpression left, PreParserExpression right, int pos) {
     return left;
   }
 
   inline void QueueDestructuringAssignmentForRewriting(PreParserExpression) {}
   inline void QueueNonPatternForRewriting(PreParserExpression) {}
 
   void SetFunctionNameFromPropertyName(PreParserExpression,
                                        PreParserIdentifier) {}
   void SetFunctionNameFromIdentifierRef(PreParserExpression,
                                         PreParserExpression) {}
 
   inline void RewriteNonPattern(Type::ExpressionClassifier* classifier,
                                 bool* ok);
 
+  inline PreParserExpression RewriteAwaitExpression(PreParserExpression value,
+                                                    int pos);
+
   V8_INLINE Zone* zone() const;
   V8_INLINE ZoneList<PreParserExpression>* GetNonPatternList() const;
 
   inline PreParserExpression RewriteYieldStar(
       PreParserExpression generator, PreParserExpression expr, int pos);
   inline PreParserExpression RewriteInstanceof(PreParserExpression lhs,
                                                PreParserExpression rhs,
                                                int pos);
 
  private:
@@ skipping 98 matching lines @@
   void ParseStatementList(int end_token, bool* ok,
                           Scanner::BookmarkScope* bookmark = nullptr);
   Statement ParseStatement(AllowLabelledFunctionStatement allow_function,
                            bool* ok);
   Statement ParseSubStatement(AllowLabelledFunctionStatement allow_function,
                               bool* ok);
   Statement ParseScopedStatement(bool legacy, bool* ok);
   Statement ParseHoistableDeclaration(bool* ok);
   Statement ParseHoistableDeclaration(int pos, bool is_generator, bool* ok);
   Statement ParseFunctionDeclaration(bool* ok);
+  Statement ParseAsyncFunctionDeclaration(bool* ok);
+  Expression ParseAsyncFunctionExpression(bool* ok);
   Statement ParseClassDeclaration(bool* ok);
   Statement ParseBlock(bool* ok);
   Statement ParseVariableStatement(VariableDeclarationContext var_context,
                                    bool* ok);
   Statement ParseVariableDeclarations(VariableDeclarationContext var_context,
                                       int* num_decl, bool* is_lexical,
                                       bool* is_binding_pattern,
                                       Scanner::Location* first_initializer_loc,
                                       Scanner::Location* bindings_loc,
                                       bool* ok);
@@ skipping 68 matching lines @@
 
 
 void PreParserTraits::ParseArrowFunctionFormalParameterList(
     PreParserFormalParameters* parameters,
     PreParserExpression params, const Scanner::Location& params_loc,
     Scanner::Location* duplicate_loc, bool* ok) {
   // TODO(wingo): Detect duplicated identifiers in paramlists.  Detect parameter
   // lists that are too long.
 }
 
+PreParserExpression PreParserTraits::ParseAsyncFunctionExpression(bool* ok) {
+  return pre_parser_->ParseAsyncFunctionExpression(ok);
+}
 
 PreParserExpression PreParserTraits::ParseDoExpression(bool* ok) {
   return pre_parser_->ParseDoExpression(ok);
 }
 
 
 void PreParserTraits::RewriteNonPattern(Type::ExpressionClassifier* classifier,
                                         bool* ok) {
   pre_parser_->ValidateExpression(classifier, ok);
 }
 
+PreParserExpression PreParserTraits::RewriteAwaitExpression(
+    PreParserExpression value, int pos) {
+  return value;
+}
 
 Zone* PreParserTraits::zone() const {
   return pre_parser_->function_state_->scope()->zone();
 }
 
 
 ZoneList<PreParserExpression>* PreParserTraits::GetNonPatternList() const {
   return pre_parser_->function_state_->non_patterns_to_rewrite();
 }
 
@@ skipping 34 matching lines @@
     const PreParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   return pre_parser_->ParseEagerFunctionBody(function_name, pos, parameters,
                                              kind, function_type, ok);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H