[es6] support rest parameters in arrow functions (alternative)

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 3593 matching lines @@
   //   () => ...
   if (expression == NULL) return true;
 
   // Too many parentheses around expression:
   //   (( ... )) => ...
   if (expression->is_multi_parenthesized()) return false;
 
   // Case for a single parameter:
   //   (foo) => ...
   //   foo => ...
+  bool is_rest;
+  if ((is_rest = expression->IsSpread())) {
+    expression = expression->AsSpread()->expression();
+  }
   if (expression->IsVariableProxy()) {
     if (expression->AsVariableProxy()->is_this()) return false;
 
     const AstRawString* raw_name = expression->AsVariableProxy()->raw_name();
     if (traits->IsEvalOrArguments(raw_name) ||
         traits->IsFutureStrictReserved(raw_name))
       return false;
 
     if (scope->IsDeclared(raw_name)) {
       *dupe_loc = Scanner::Location(
           expression->position(), expression->position() + raw_name->length());
       return false;
     }
 
-    scope->DeclareParameter(raw_name, VAR);
+    scope->DeclareParameter(raw_name, VAR, is_rest);
     ++(*num_params);
     return true;
   }
 
   // Case for more than one parameter:
   //   (foo, bar [, ...]) => ...
   if (expression->IsBinaryOperation()) {
     BinaryOperation* binop = expression->AsBinaryOperation();
     if (binop->op() != Token::COMMA || binop->left()->is_parenthesized() ||
         binop->right()->is_parenthesized())
@@ skipping 532 matching lines @@
   VariableProxy* proxy = NULL;
   if (name != NULL) {
     proxy = NewUnresolved(name, CONST);
     Declaration* declaration =
         factory()->NewVariableDeclaration(proxy, CONST, block_scope, pos);
     Declare(declaration, true, CHECK_OK);
   }
 
   Expression* extends = NULL;
   if (Check(Token::EXTENDS)) {
+    const bool maybeArrow = false;
     block_scope->set_start_position(scanner()->location().end_pos);
-    extends = ParseLeftHandSideExpression(CHECK_OK);
+    extends = ParseLeftHandSideExpression(maybeArrow, CHECK_OK);
   } else {
     block_scope->set_start_position(scanner()->location().end_pos);
   }
 
 
   ClassLiteralChecker checker(this);
   ZoneList<ObjectLiteral::Property*>* properties = NewPropertyList(4, zone());
   FunctionLiteral* constructor = NULL;
   bool has_seen_constructor = false;
 
@@ skipping 1318 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal