[parser] report errors for invalid binding patterns in async formal parameters

src/parsing/parser-base.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_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 879 matching lines @@
   }
 
   bool IsValidArrowFormalParametersStart(Token::Value token) {
     return is_any_identifier(token) || token == Token::LPAREN;
   }
 
   void ValidateArrowFormalParameters(const ExpressionClassifier* classifier,
                                      ExpressionT expr,
                                      bool parenthesized_formals, bool is_async,
                                      bool* ok) {
-    if (classifier->is_valid_binding_pattern()) {
+    if (!is_async && classifier->is_valid_binding_pattern() &&
+        !this->IsIdentifier(expr)) {

[nickie, 2016/07/12 12:27:13]

Merging the conditions and removing the "else" changed the semantics.  I suggest
that you keep the two ifs.

       // A simple arrow formal parameter: IDENTIFIER => BODY.
-      if (!this->IsIdentifier(expr)) {
-        Traits::ReportMessageAt(scanner()->location(),
-                                MessageTemplate::kUnexpectedToken,
-                                Token::String(scanner()->current_token()));
-        *ok = false;
-      }
-    } else if (!classifier->is_valid_arrow_formal_parameters()) {
+      Traits::ReportMessageAt(scanner()->location(),
+                              MessageTemplate::kUnexpectedToken,
+                              Token::String(scanner()->current_token()));
+      *ok = false;
+      return;
+    }
+
+    if (!classifier->is_valid_arrow_formal_parameters()) {
       // If after parsing the expr, we see an error but the expression is
       // neither a valid binding pattern nor a valid parenthesized formal
       // parameter list, show the "arrow formal parameters" error if the formals
       // started with a parenthesis, and the binding pattern error otherwise.
       const typename ExpressionClassifier::Error& error =
           parenthesized_formals ? classifier->arrow_formal_parameters_error()
                                 : classifier->binding_pattern_error();
       ReportClassifierError(error);
       *ok = false;
+      return;
     }
-    if (is_async && !classifier->is_valid_async_arrow_formal_parameters()) {
-      const typename ExpressionClassifier::Error& error =
-          classifier->async_arrow_formal_parameters_error();
-      ReportClassifierError(error);
-      *ok = false;
+
+    if (is_async) {
+      if (!classifier->is_valid_async_arrow_formal_parameters()) {
+        const typename ExpressionClassifier::Error& error =
+            classifier->async_arrow_formal_parameters_error();
+        ReportClassifierError(error);
+        *ok = false;
+        return;
+      }
+      if (!classifier->is_valid_binding_pattern()) {
+        ReportClassifierError(classifier->binding_pattern_error());
+        *ok = false;
+        return;
+      }
     }
   }
 
   void ValidateLetPattern(const ExpressionClassifier* classifier, bool* ok) {
     if (!classifier->is_valid_let_pattern()) {
       ReportClassifierError(classifier->let_pattern_error());
       *ok = false;
     }
   }
 
@@ skipping 83 matching lines @@
       Scanner::Location* first_spread_pos, bool maybe_arrow,
       ExpressionClassifier* classifier, bool* ok);
   typename Traits::Type::ExpressionList ParseArguments(
       Scanner::Location* first_spread_pos, ExpressionClassifier* classifier,
       bool* ok) {
     return ParseArguments(first_spread_pos, false, classifier, ok);
   }
 
   ExpressionT ParseAssignmentExpression(bool accept_IN,
                                         ExpressionClassifier* classifier,
-                                        bool* ok);
+                                        bool merge_patterns, bool* ok);
+  ExpressionT ParseAssignmentExpression(bool accept_IN,
+                                        ExpressionClassifier* classifier,
+                                        bool* ok) {
+    return ParseAssignmentExpression(accept_IN, classifier, false, ok);
+  }
   ExpressionT ParseYieldExpression(bool accept_IN,
                                    ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParseTailCallExpression(ExpressionClassifier* classifier,
                                       bool* ok);
   ExpressionT ParseConditionalExpression(bool accept_IN,
                                          ExpressionClassifier* classifier,
                                          bool* ok);
   ExpressionT ParseBinaryExpression(int prec, bool accept_IN,
                                     ExpressionClassifier* classifier, bool* ok);
   ExpressionT ParseUnaryExpression(ExpressionClassifier* classifier, bool* ok);
@@ skipping 1127 matching lines @@
   Expect(Token::LPAREN, CHECK_OK_CUSTOM(NullExpressionList));
   bool done = (peek() == Token::RPAREN);
   bool was_unspread = false;
   int unspread_sequences_count = 0;
   while (!done) {
     int start_pos = peek_position();
     bool is_spread = Check(Token::ELLIPSIS);
     int expr_pos = peek_position();
 
     ExpressionT argument = this->ParseAssignmentExpression(
-        true, classifier, CHECK_OK_CUSTOM(NullExpressionList));
+        true, classifier, maybe_arrow, CHECK_OK_CUSTOM(NullExpressionList));
     CheckNoTailCallExpressions(classifier, CHECK_OK_CUSTOM(NullExpressionList));
     if (!maybe_arrow) {
       Traits::RewriteNonPattern(classifier,
                                 CHECK_OK_CUSTOM(NullExpressionList));
     }
     if (is_spread) {
       if (!spread_arg.IsValid()) {
         spread_arg.beg_pos = start_pos;
         spread_arg.end_pos = peek_position();
       }
@@ skipping 46 matching lines @@
   }
 
   return result;
 }
 
 // Precedence = 2
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseAssignmentExpression(bool accept_IN,
                                               ExpressionClassifier* classifier,
-                                              bool* ok) {
+                                              bool merge_patterns, bool* ok) {
   // AssignmentExpression ::
   //   ConditionalExpression
   //   ArrowFunction
   //   YieldExpression
   //   LeftHandSideExpression AssignmentOperator AssignmentExpression
   bool is_destructuring_assignment = false;
   int lhs_beg_pos = peek_position();
 
   if (peek() == Token::YIELD && is_generator()) {
     return this->ParseYieldExpression(accept_IN, classifier, ok);
@@ skipping 71 matching lines @@
     return expression;
   }
 
   if (this->IsValidReferenceExpression(expression)) {
     arrow_formals_classifier.ForgiveAssignmentPatternError();
   }
 
   // "expression" was not itself an arrow function parameter list, but it might
   // form part of one.  Propagate speculative formal parameter error locations.
   // Do not merge pending non-pattern expressions yet!
-  classifier->Accumulate(
-      &arrow_formals_classifier,
+  int productions_to_propagate =
       ExpressionClassifier::StandardProductions |
-          ExpressionClassifier::FormalParametersProductions |
-          ExpressionClassifier::CoverInitializedNameProduction |
-          ExpressionClassifier::AsyncArrowFormalParametersProduction |
-          ExpressionClassifier::AsyncBindingPatternProduction,
-      false);
+      ExpressionClassifier::FormalParametersProductions |
+      ExpressionClassifier::CoverInitializedNameProduction |
+      ExpressionClassifier::AsyncArrowFormalParametersProduction |
+      ExpressionClassifier::AsyncBindingPatternProduction;
+  if (merge_patterns) {
+    productions_to_propagate |= ExpressionClassifier::BindingPatternProduction;
+  }
+
+  classifier->Accumulate(&arrow_formals_classifier, productions_to_propagate,
+                         false);
 
   if (!Token::IsAssignmentOp(peek())) {
     // Parsed conditional expression only (no assignment).
     // Now pending non-pattern expressions must be merged.
     classifier->MergeNonPatterns(&arrow_formals_classifier);
     return expression;
   }
 
   // Now pending non-pattern expressions must be discarded.
   arrow_formals_classifier.Discard();
@@ skipping 446 matching lines @@
         Traits::RewriteNonPattern(classifier, CHECK_OK);
         result = factory()->NewProperty(result, index, pos);
         Expect(Token::RBRACK, CHECK_OK);
         break;
       }
 
       case Token::LPAREN: {
         CheckNoTailCallExpressions(classifier, CHECK_OK);
         int pos;
         Traits::RewriteNonPattern(classifier, CHECK_OK);
-        BindingPatternUnexpectedToken(classifier);
+
+        const char* arg;
+        MessageTemplate::Template message = MessageTemplate::kUnexpectedToken;
+        Scanner::Location location = scanner()->peek_location();
+        GetUnexpectedTokenMessage(peek(), &message, &location, &arg);
+
+        if (!is_async) {
+          classifier->RecordBindingPatternError(location, message, arg);
+        }
+
         if (scanner()->current_token() == Token::IDENTIFIER ||
             scanner()->current_token() == Token::SUPER ||
             scanner()->current_token() == Token::ASYNC) {
           // For call of an identifier we want to report position of
           // the identifier as position of the call in the stack trace.
           pos = position();
         } else {
           // For other kinds of calls we record position of the parenthesis as
           // position of the call. Note that this is extremely important for
           // expressions of the form function(){...}() for which call position
@@ skipping 11 matching lines @@
         typename Traits::Type::ExpressionList args =
             ParseArguments(&spread_pos, is_async, classifier, CHECK_OK);
 
         if (V8_UNLIKELY(is_async && peek() == Token::ARROW)) {
           if (args->length()) {
             // async ( Arguments ) => ...
             return Traits::ExpressionListToExpression(args);
           }
           // async () => ...
           return factory()->NewEmptyParentheses(pos);
+        } else {
+          classifier->ReplaceBindingPatternError(location, message, arg);
         }
 
         ArrowFormalParametersUnexpectedToken(classifier);
 
         // Keep track of eval() calls since they disable all local variable
         // optimizations.
         // The calls that need special treatment are the
         // direct eval calls. These calls are all of the form eval(...), with
         // no explicit receiver.
         // These calls are marked as potentially direct eval calls. Whether
@@ skipping 801 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H