[es6] Re-implement rest parameters via desugaring.

src/parser.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_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // TODO(titzer): remove this include dependency
@@ skipping 1302 matching lines @@
 
 Expression* ParserTraits::SpreadCallNew(
     Expression* function, ZoneList<v8::internal::Expression*>* args, int pos) {
   return parser_->SpreadCallNew(function, args, pos);
 }
 
 
 void ParserTraits::AddFormalParameter(
     ParserFormalParameters* parameters,
     Expression* pattern, Expression* initializer, bool is_rest) {
-  bool is_simple = pattern->IsVariableProxy() && initializer == nullptr;
+  bool is_simple =
+      !is_rest && pattern->IsVariableProxy() && initializer == nullptr;

[caitp (gmail), 2015/09/02 20:11:31]

This makes sure the empty string is used instead of the variable name, so that
the variable doesn't get declared twice. This seems to fix the bug in the tests.
I'm not sure if this code should be here, or maybe live somewhere else, but it
should be okay either way.

[rossberg, 2015/09/02 20:44:10]

Yes, this looks right to me.

   DCHECK(parser_->allow_harmony_destructuring() ||
          parser_->allow_harmony_rest_parameters() ||
          parser_->allow_harmony_default_parameters() || is_simple);
   const AstRawString* name = is_simple
                                  ? pattern->AsVariableProxy()->raw_name()
                                  : parser_->ast_value_factory()->empty_string();
   parameters->params.Add(
       ParserFormalParameters::Parameter(name, pattern, initializer, is_rest),
       parameters->scope->zone());
 }
 
 
 void ParserTraits::DeclareFormalParameter(
     Scope* scope, const ParserFormalParameters::Parameter& parameter,
     ExpressionClassifier* classifier) {
   bool is_duplicate = false;
   bool is_simple = classifier->is_simple_parameter_list();
-  // TODO(caitp): Remove special handling for rest once desugaring is in.
-  auto name = is_simple || parameter.is_rest
-      ? parameter.name : parser_->ast_value_factory()->empty_string();
-  auto mode = is_simple || parameter.is_rest ? VAR : TEMPORARY;
+  auto name = parameter.name;
+  auto mode = is_simple ? VAR : TEMPORARY;
   if (!is_simple) scope->SetHasNonSimpleParameters();
   bool is_optional = parameter.initializer != nullptr;
   Variable* var = scope->DeclareParameter(
       name, mode, is_optional, parameter.is_rest, &is_duplicate);
   if (is_duplicate) {
     classifier->RecordDuplicateFormalParameterError(
         parser_->scanner()->location());
   }
   if (is_sloppy(scope->language_mode())) {
     // TODO(sigurds) Mark every parameter as maybe assigned. This is a
@@ skipping 12 matching lines @@
         parser_->BuildParameterInitializationBlock(parameters, ok);
     if (!*ok) return;
     if (init_block != nullptr) {
       body->Add(init_block, parser_->zone());
     }
   }
 }
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_