Support rest parameters in arrow functions

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 3741 matching lines @@
   Smi* literal_type = Smi::cast(value->get(kLiteralTypeSlot));
   return static_cast<LiteralType>(literal_type->value());
 }
 
 
 Handle<FixedArray> CompileTimeValue::GetElements(Handle<FixedArray> value) {
   return Handle<FixedArray>(FixedArray::cast(value->get(kElementsSlot)));
 }
 
 
-void ParserTraits::DeclareArrowFunctionParameters(
+void ParserTraits::ParseArrowFunctionFormalParameters(
     Scope* scope, Expression* expr, const Scanner::Location& params_loc,
-    Scanner::Location* duplicate_loc, bool* ok) {
+    bool has_rest, Scanner::Location* duplicate_loc, bool* ok) {
   if (scope->num_parameters() >= Code::kMaxArguments) {
     ReportMessageAt(params_loc, MessageTemplate::kMalformedArrowFunParamList);
     *ok = false;
     return;
   }
 
   // ArrowFunctionFormals ::
   //    Binary(Token::COMMA, ArrowFunctionFormals, VariableProxy)
   //    VariableProxy
   //
   // As we need to visit the parameters in left-to-right order, we recurse on
   // the left-hand side of comma expressions.
   //
   // Sadly, for the various malformed_arrow_function_parameter_list errors, we
   // can't be more specific on the error message or on the location because we
   // need to match the pre-parser's behavior.
   if (expr->IsBinaryOperation()) {
     BinaryOperation* binop = expr->AsBinaryOperation();
     // The classifier has already run, so we know that the expression is a valid
     // arrow function formals production.
     DCHECK_EQ(binop->op(), Token::COMMA);
     Expression* left = binop->left();
     Expression* right = binop->right();
-    DeclareArrowFunctionParameters(scope, left, params_loc, duplicate_loc, ok);
+    // Only the right-most expression may be a rest parameter.
+    bool has_rest = false;
+    ParseArrowFunctionFormalParameters(scope, left, params_loc, has_rest,
+                                       duplicate_loc, ok);
     if (!*ok) return;
     // LHS of comma expression should be unparenthesized.
     expr = right;
   }
 
-  // TODO(wingo): Support rest parameters.
   DCHECK(expr->IsVariableProxy());
   DCHECK(!expr->AsVariableProxy()->is_this());
 
   const AstRawString* raw_name = expr->AsVariableProxy()->raw_name();
   Scanner::Location param_location(expr->position(),
                                    expr->position() + raw_name->length());
 
   // When the formal parameter was originally seen, it was parsed as a
   // VariableProxy and recorded as unresolved in the scope.  Here we undo that
   // parse-time side-effect.
   parser_->scope_->RemoveUnresolved(expr->AsVariableProxy());
 
-  bool is_rest = false;
   ExpressionClassifier classifier;
-  DeclareFormalParameter(scope, raw_name, &classifier, is_rest);
-  *duplicate_loc = classifier.duplicate_formal_parameter_error().location;
+  DeclareFormalParameter(scope, raw_name, &classifier, has_rest);
+  if (!duplicate_loc->IsValid()) {

[Dmitry Lomov (no reviews), 2015/06/10 11:04:41]

Oops, thanks for fixing this! Can we add a test that fails without this fix? (ok
in separate CL)

[wingo, 2015/06/10 13:21:10]

Sure.  I'll see if I can cook one up for this CL actually.

+    *duplicate_loc = classifier.duplicate_formal_parameter_error().location;
+  }
 }
 
 
-void ParserTraits::ParseArrowFunctionFormalParameters(
-    Scope* scope, Expression* params, const Scanner::Location& params_loc,
-    bool* is_rest, Scanner::Location* duplicate_loc, bool* ok) {
-  DeclareArrowFunctionParameters(scope, params, params_loc, duplicate_loc, ok);
-}
-
-
 FunctionLiteral* Parser::ParseFunctionLiteral(
     const AstRawString* function_name, Scanner::Location function_name_location,
     bool name_is_strict_reserved, FunctionKind kind, int function_token_pos,
     FunctionLiteral::FunctionType function_type,
     FunctionLiteral::ArityRestriction arity_restriction, bool* ok) {
   // Function ::
   //   '(' FormalParameterList? ')' '{' FunctionBody '}'
   //
   // Getter ::
   //   '(' ')' '{' FunctionBody '}'
@@ skipping 1988 matching lines @@
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 }  // namespace internal
 }  // namespace v8