[esnext] implement frontend changes for async/await proposal

src/parsing/expression-classifier.h

 // Copyright 2015 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_EXPRESSION_CLASSIFIER_H
 #define V8_PARSING_EXPRESSION_CLASSIFIER_H
 
 #include "src/messages.h"
 #include "src/parsing/scanner.h"
 #include "src/parsing/token.h"
@@ skipping 22 matching lines @@
     ExpressionProduction = 1 << 0,
     FormalParameterInitializerProduction = 1 << 1,
     BindingPatternProduction = 1 << 2,
     AssignmentPatternProduction = 1 << 3,
     DistinctFormalParametersProduction = 1 << 4,
     StrictModeFormalParametersProduction = 1 << 5,
     ArrowFormalParametersProduction = 1 << 6,
     LetPatternProduction = 1 << 7,
     CoverInitializedNameProduction = 1 << 8,
     TailCallExpressionProduction = 1 << 9,
+    AsyncArrowFormalParametersProduction = 1 << 10,
 
     ExpressionProductions =
         (ExpressionProduction | FormalParameterInitializerProduction |
          TailCallExpressionProduction),
     PatternProductions = (BindingPatternProduction |
                           AssignmentPatternProduction | LetPatternProduction),
     FormalParametersProductions = (DistinctFormalParametersProduction |
                                    StrictModeFormalParametersProduction),
     StandardProductions = ExpressionProductions | PatternProductions,
     AllProductions =
         (StandardProductions | FormalParametersProductions |
-         ArrowFormalParametersProduction | CoverInitializedNameProduction)
+         ArrowFormalParametersProduction | CoverInitializedNameProduction |
+         AsyncArrowFormalParametersProduction)
   };
 
   enum FunctionProperties { NonSimpleParameter = 1 << 0 };
 
   explicit ExpressionClassifier(const Traits* t)
       : zone_(t->zone()),
         non_patterns_to_rewrite_(t->GetNonPatternList()),
         invalid_productions_(0),
         function_properties_(0),
         duplicate_finder_(nullptr) {
@@ skipping 40 matching lines @@
   }
 
   // Note: callers should also check
   // is_valid_formal_parameter_list_without_duplicates().
   bool is_valid_strict_mode_formal_parameters() const {
     return is_valid(StrictModeFormalParametersProduction);
   }
 
   bool is_valid_let_pattern() const { return is_valid(LetPatternProduction); }
 
+  bool is_valid_async_arrow_formal_parameters() const {
+    return is_valid(AsyncArrowFormalParametersProduction);
+  }
+
   const Error& expression_error() const { return expression_error_; }
 
   const Error& formal_parameter_initializer_error() const {
     return formal_parameter_initializer_error_;
   }
 
   const Error& binding_pattern_error() const { return binding_pattern_error_; }
 
   const Error& assignment_pattern_error() const {
     return assignment_pattern_error_;
@@ skipping 19 matching lines @@
   const Error& cover_initialized_name_error() const {
     return cover_initialized_name_error_;
   }
 
   bool has_tail_call_expression() const {
     return !is_valid(TailCallExpressionProduction);
   }
   const Error& tail_call_expression_error() const {
     return tail_call_expression_error_;
   }
+  const Error& async_arrow_formal_parameters_error() const {
+    return async_arrow_formal_parameters_error_;
+  }
 
   bool is_simple_parameter_list() const {
     return !(function_properties_ & NonSimpleParameter);
   }
 
   void RecordNonSimpleParameter() {
     function_properties_ |= NonSimpleParameter;
   }
 
   void RecordExpressionError(const Scanner::Location& loc,
@@ skipping 57 matching lines @@
   void RecordArrowFormalParametersError(const Scanner::Location& loc,
                                         MessageTemplate::Template message,
                                         const char* arg = nullptr) {
     if (!is_valid_arrow_formal_parameters()) return;
     invalid_productions_ |= ArrowFormalParametersProduction;
     arrow_formal_parameters_error_.location = loc;
     arrow_formal_parameters_error_.message = message;
     arrow_formal_parameters_error_.arg = arg;
   }
 
+  void RecordAsyncArrowFormalParametersError(const Scanner::Location& loc,
+                                             MessageTemplate::Template message,
+                                             const char* arg = nullptr) {
+    if (!is_valid_async_arrow_formal_parameters()) return;
+    invalid_productions_ |= AsyncArrowFormalParametersProduction;
+    async_arrow_formal_parameters_error_.location = loc;
+    async_arrow_formal_parameters_error_.message = message;
+    async_arrow_formal_parameters_error_.arg = arg;
+  }
+
   void RecordDuplicateFormalParameterError(const Scanner::Location& loc) {
     if (!is_valid_formal_parameter_list_without_duplicates()) return;
     invalid_productions_ |= DistinctFormalParametersProduction;
     duplicate_formal_parameter_error_.location = loc;
     duplicate_formal_parameter_error_.message = MessageTemplate::kParamDupe;
     duplicate_formal_parameter_error_.arg = nullptr;
   }
 
   // Record a binding that would be invalid in strict mode.  Confusingly this
   // is not the same as StrictFormalParameterList, which simply forbids
@@ skipping 78 matching lines @@
             inner->duplicate_formal_parameter_error_;
       if (errors & StrictModeFormalParametersProduction)
         strict_mode_formal_parameter_error_ =
             inner->strict_mode_formal_parameter_error_;
       if (errors & LetPatternProduction)
         let_pattern_error_ = inner->let_pattern_error_;
       if (errors & CoverInitializedNameProduction)
         cover_initialized_name_error_ = inner->cover_initialized_name_error_;
       if (errors & TailCallExpressionProduction)
         tail_call_expression_error_ = inner->tail_call_expression_error_;
+      if (errors & AsyncArrowFormalParametersProduction)
+        async_arrow_formal_parameters_error_ =
+            inner->async_arrow_formal_parameters_error_;
     }
 
     // As an exception to the above, the result continues to be a valid arrow
     // formal parameters if the inner expression is a valid binding pattern.
     if (productions & ArrowFormalParametersProduction &&
         is_valid_arrow_formal_parameters()) {
       // Also copy function properties if expecting an arrow function
       // parameter.
       function_properties_ |= inner->function_properties_;
 
@@ skipping 27 matching lines @@
   Error expression_error_;
   Error formal_parameter_initializer_error_;
   Error binding_pattern_error_;
   Error assignment_pattern_error_;
   Error arrow_formal_parameters_error_;
   Error duplicate_formal_parameter_error_;
   Error strict_mode_formal_parameter_error_;
   Error let_pattern_error_;
   Error cover_initialized_name_error_;
   Error tail_call_expression_error_;
+  Error async_arrow_formal_parameters_error_;
   DuplicateFinder* duplicate_finder_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_EXPRESSION_CLASSIFIER_H