[destructuring] Parse binding patterns in formal parameters.

src/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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 537 matching lines @@
                !classifier->is_valid_strong_mode_formal_parameters()) {
       ReportClassifierError(classifier->strong_mode_formal_parameter_error());
       *ok = false;
     }
   }
 
   void ValidateArrowFormalParameters(const ExpressionClassifier* classifier,
                                      ExpressionT expr, bool* ok) {
     if (classifier->is_valid_binding_pattern()) {
       // A simple arrow formal parameter: IDENTIFIER => BODY.
-      if (!this->IsIdentifier(expr)) {
+      if (!allow_harmony_destructuring() && !this->IsIdentifier(expr)) {
         Traits::ReportMessageAt(scanner()->location(),
                                 MessageTemplate::kUnexpectedToken,
                                 Token::String(scanner()->current_token()));
         *ok = false;
       }
     } else if (!classifier->is_valid_arrow_formal_parameters()) {
       ReportClassifierError(classifier->arrow_formal_parameters_error());
       *ok = false;
     }
   }
@@ skipping 979 matching lines @@
     return EmptyExpression();
   }
   inline void MaterializeTemplateCallsiteLiterals();
   PreParserExpression NoTemplateTag() {
     return PreParserExpression::NoTemplateTag();
   }
   static bool IsTaggedTemplate(const PreParserExpression tag) {
     return !tag.IsNoTemplateTag();
   }
 
-  void DeclareFormalParameter(Scope* scope, PreParserIdentifier param,
+  void DeclareFormalParameter(Scope* scope, PreParserExpression pattern,
                               ExpressionClassifier* classifier, bool is_rest) {}
 
   void CheckConflictingVarDeclarations(Scope* scope, bool* ok) {}
 
   // Temporary glue; these functions will move to ParserBase.
   PreParserExpression ParseV8Intrinsic(bool* ok);
   PreParserExpression ParseFunctionLiteral(
       PreParserIdentifier name, Scanner::Location function_name_location,
       bool name_is_strict_reserved, FunctionKind kind,
       int function_token_position, FunctionLiteral::FunctionType type,
@@ skipping 1911 matching lines @@
   return this->EmptyExpression();
 }
 
 
 template <class Traits>
 void ParserBase<Traits>::ParseFormalParameter(Scope* scope, bool is_rest,
                                               ExpressionClassifier* classifier,
                                               bool* ok) {
   // FormalParameter[Yield,GeneratorParameter] :
   //   BindingElement[?Yield, ?GeneratorParameter]
-  IdentifierT name = ParseAndClassifyIdentifier(classifier, ok);
+
+  Token::Value next = peek();
+  ExpressionT pattern = ParsePrimaryExpression(classifier, ok);
   if (!*ok) return;
 
-  Traits::DeclareFormalParameter(scope, name, classifier, is_rest);
+  ValidateBindingPattern(classifier, ok);
+  if (!*ok) return;
+
+  if (!allow_harmony_destructuring() && !Traits::IsIdentifier(pattern)) {
+    ReportUnexpectedToken(next);
+    *ok = false;
+    return;
+  }
+
+  Traits::DeclareFormalParameter(scope, pattern, classifier, is_rest);
 }
 
 
 template <class Traits>
 int ParserBase<Traits>::ParseFormalParameterList(
     Scope* scope, bool* is_rest, ExpressionClassifier* classifier, bool* ok) {
   // FormalParameters[Yield,GeneratorParameter] :
   //   [empty]
   //   FormalParameterList[?Yield, ?GeneratorParameter]
   //
@@ skipping 342 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H