[async functions] Disallow 'await' in arrow params inside async functions

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"
 
 namespace v8 {
 namespace internal {
 
-
-#define ERROR_CODES(T)                          \
-  T(ExpressionProduction, 0)                    \
-  T(FormalParameterInitializerProduction, 1)    \
-  T(BindingPatternProduction, 2)                \
-  T(AssignmentPatternProduction, 3)             \
-  T(DistinctFormalParametersProduction, 4)      \
-  T(StrictModeFormalParametersProduction, 5)    \
-  T(ArrowFormalParametersProduction, 6)         \
-  T(LetPatternProduction, 7)                    \
-  T(ObjectLiteralProduction, 8)                 \
-  T(TailCallExpressionProduction, 9)            \
-  T(AsyncArrowFormalParametersProduction, 10)   \
-  T(AsyncBindingPatternProduction, 11)
+#define ERROR_CODES(T)                       \
+  T(ExpressionProduction, 0)                 \
+  T(FormalParameterInitializerProduction, 1) \
+  T(BindingPatternProduction, 2)             \
+  T(AssignmentPatternProduction, 3)          \
+  T(DistinctFormalParametersProduction, 4)   \
+  T(StrictModeFormalParametersProduction, 5) \
+  T(ArrowFormalParametersProduction, 6)      \
+  T(LetPatternProduction, 7)                 \
+  T(ObjectLiteralProduction, 8)              \
+  T(TailCallExpressionProduction, 9)         \
+  T(AsyncArrowFormalParametersProduction, 10)
 
 template <typename Traits>
 class ExpressionClassifier {
  public:
   enum ErrorKind : unsigned {
 #define DEFINE_ERROR_KIND(NAME, CODE) k##NAME = CODE,
     ERROR_CODES(DEFINE_ERROR_KIND)
 #undef DEFINE_ERROR_KIND
     kUnusedError = 15  // Larger than error codes; should fit in 4 bits
   };
@@ skipping 16 matching lines @@
     unsigned kind : 4;
     ParseErrorType type : 2;
     const char* arg;
   };
 
   enum TargetProduction : unsigned {
 #define DEFINE_PRODUCTION(NAME, CODE) NAME = 1 << CODE,
     ERROR_CODES(DEFINE_PRODUCTION)
 #undef DEFINE_PRODUCTION
 
-    ExpressionProductions =
-        (ExpressionProduction | FormalParameterInitializerProduction |
-         TailCallExpressionProduction),
-    PatternProductions =
-        (BindingPatternProduction | AssignmentPatternProduction |
-         LetPatternProduction | AsyncBindingPatternProduction),
+        ExpressionProductions =
+            (ExpressionProduction | FormalParameterInitializerProduction |
+             TailCallExpressionProduction),
+    PatternProductions = (BindingPatternProduction |
+                          AssignmentPatternProduction | LetPatternProduction),
     FormalParametersProductions = (DistinctFormalParametersProduction |
                                    StrictModeFormalParametersProduction),
     AllProductions =
         (ExpressionProductions | PatternProductions |
          FormalParametersProductions | ArrowFormalParametersProduction |
          ObjectLiteralProduction | AsyncArrowFormalParametersProduction)
   };
 
   enum FunctionProperties : unsigned {
     NonSimpleParameter = 1 << 0
@@ skipping 62 matching lines @@
   }
 
   V8_INLINE bool is_valid_let_pattern() const {
     return is_valid(LetPatternProduction);
   }
 
   bool is_valid_async_arrow_formal_parameters() const {
     return is_valid(AsyncArrowFormalParametersProduction);
   }
 
-  bool is_valid_async_binding_pattern() const {
-    return is_valid(AsyncBindingPatternProduction);
-  }
-
   V8_INLINE const Error& expression_error() const {
     return reported_error(kExpressionProduction);
   }
 
   V8_INLINE const Error& formal_parameter_initializer_error() const {
     return reported_error(kFormalParameterInitializerProduction);
   }
 
   V8_INLINE const Error& binding_pattern_error() const {
     return reported_error(kBindingPatternProduction);
@@ skipping 31 matching lines @@
     return !is_valid(TailCallExpressionProduction);
   }
   V8_INLINE const Error& tail_call_expression_error() const {
     return reported_error(kTailCallExpressionProduction);
   }
 
   V8_INLINE const Error& async_arrow_formal_parameters_error() const {
     return reported_error(kAsyncArrowFormalParametersProduction);
   }
 
-  V8_INLINE const Error& async_binding_pattern_error() const {
-    return reported_error(kAsyncBindingPatternProduction);
-  }
-
   V8_INLINE bool is_simple_parameter_list() const {
     return !(function_properties_ & NonSimpleParameter);
   }
 
   V8_INLINE void RecordNonSimpleParameter() {
     function_properties_ |= NonSimpleParameter;
   }
 
   void RecordExpressionError(const Scanner::Location& loc,
                              MessageTemplate::Template message,
@@ skipping 51 matching lines @@
   }
 
   void RecordAsyncArrowFormalParametersError(const Scanner::Location& loc,
                                              MessageTemplate::Template message,
                                              const char* arg = nullptr) {
     if (!is_valid_async_arrow_formal_parameters()) return;
     invalid_productions_ |= AsyncArrowFormalParametersProduction;
     Add(Error(loc, message, kAsyncArrowFormalParametersProduction, arg));
   }
 
-  void RecordAsyncBindingPatternError(const Scanner::Location& loc,
-                                      MessageTemplate::Template message,
-                                      const char* arg = nullptr) {
-    if (!is_valid_async_binding_pattern()) return;
-    invalid_productions_ |= AsyncBindingPatternProduction;
-    Add(Error(loc, message, kAsyncBindingPatternProduction, arg));
-  }
-
   void RecordDuplicateFormalParameterError(const Scanner::Location& loc) {
     if (!is_valid_formal_parameter_list_without_duplicates()) return;
     invalid_productions_ |= DistinctFormalParametersProduction;
     Add(Error(loc, MessageTemplate::kParamDupe,
               kDistinctFormalParametersProduction));
   }
 
   // Record a binding that would be invalid in strict mode.  Confusingly this
   // is not the same as StrictFormalParameterList, which simply forbids
   // duplicate bindings.
@@ skipping 191 matching lines @@
 };
 
 
 #undef ERROR_CODES
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_EXPRESSION_CLASSIFIER_H