Partial revert of rest parameter desugaring.

src/parsing/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/parsing/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-visitor.h"
 #include "src/ast/ast-literal-reindexer.h"
@@ skipping 4098 matching lines @@
     expr = right;
   }
 
   // Only the right-most expression may be a rest parameter.
   DCHECK(!parameters->has_rest);
 
   bool is_rest = expr->IsSpread();
   if (is_rest) {
     expr = expr->AsSpread()->expression();
     parameters->has_rest = true;
-    parameters->rest_array_literal_index =
-        parser_->function_state_->NextMaterializedLiteralIndex();
-    ++parameters->materialized_literals_count;
   }
   if (parameters->is_simple) {
     parameters->is_simple = !is_rest && expr->IsVariableProxy();
   }
 
   Expression* initializer = nullptr;
   if (expr->IsVariableProxy()) {
     // 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 for parameters that are single-names (not
@@ skipping 64 matching lines @@
 
 void ParserTraits::ReindexLiterals(const ParserFormalParameters& parameters) {
   if (parser_->function_state_->materialized_literal_count() > 0) {
     AstLiteralReindexer reindexer;
 
     for (const auto p : parameters.params) {
       if (p.pattern != nullptr) reindexer.Reindex(p.pattern);
       if (p.initializer != nullptr) reindexer.Reindex(p.initializer);
     }
 
-    if (parameters.has_rest) {
-      parameters.rest_array_literal_index = reindexer.NextIndex();
-    }
-
     DCHECK(reindexer.count() <=
            parser_->function_state_->materialized_literal_count());
   }
 }
 
 
 FunctionLiteral* Parser::ParseFunctionLiteral(
     const AstRawString* function_name, Scanner::Location function_name_location,
     FunctionNameValidity function_name_validity, FunctionKind kind,
     int function_token_pos, FunctionLiteral::FunctionType function_type,
@@ skipping 259 matching lines @@
 
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       function_name, ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, arity,
       duplicate_parameters, function_type, FunctionLiteral::kIsFunction,
       eager_compile_hint, kind, pos);
   function_literal->set_function_token_position(function_token_pos);
   if (should_be_used_once_hint)
     function_literal->set_should_be_used_once_hint();
 
+  if (scope->has_rest_parameter()) {
+    function_literal->set_dont_optimize_reason(kRestParameter);
+  }
+
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }
 
 
 void Parser::SkipLazyFunctionBody(int* materialized_literal_count,
                                   int* expected_property_count, bool* ok,
                                   Scanner::BookmarkScope* bookmark) {
   DCHECK_IMPLIES(bookmark, bookmark->HasBeenSet());
   if (produce_cached_parse_data()) CHECK(log_);
@@ skipping 129 matching lines @@
 
 
 Block* Parser::BuildParameterInitializationBlock(
     const ParserFormalParameters& parameters, bool* ok) {
   DCHECK(!parameters.is_simple);
   DCHECK(scope_->is_function_scope());
   Block* init_block =
       factory()->NewBlock(NULL, 1, true, RelocInfo::kNoPosition);
   for (int i = 0; i < parameters.params.length(); ++i) {
     auto parameter = parameters.params[i];
+    if (parameter.is_rest) break;
     DeclarationDescriptor descriptor;
     descriptor.declaration_kind = DeclarationDescriptor::PARAMETER;
     descriptor.parser = this;
     descriptor.scope = scope_;
     descriptor.hoist_scope = nullptr;
     descriptor.mode = LET;
     descriptor.needs_init = true;
     descriptor.declaration_pos = parameter.pattern->position();
     // The position that will be used by the AssignmentExpression
     // which copies from the temp parameter to the pattern.
     //
     // TODO(adamk): Should this be RelocInfo::kNoPosition, since
     // it's just copying from a temp var to the real param var?
     descriptor.initialization_pos = parameter.pattern->position();
     // The initializer position which will end up in,
     // Variable::initializer_position(), used for hole check elimination.
     int initializer_position = parameter.pattern->position();
     Expression* initial_value =
         factory()->NewVariableProxy(parameters.scope->parameter(i));
     if (parameter.initializer != nullptr) {
       // IS_UNDEFINED($param) ? initializer : $param
-      DCHECK(!parameter.is_rest);
 
       // Ensure initializer is rewritten
       RewriteParameterInitializer(parameter.initializer, scope_);
 
       auto condition = factory()->NewCompareOperation(
           Token::EQ_STRICT,
           factory()->NewVariableProxy(parameters.scope->parameter(i)),
           factory()->NewUndefinedLiteral(RelocInfo::kNoPosition),
           RelocInfo::kNoPosition);
       initial_value = factory()->NewConditional(
           condition, parameter.initializer, initial_value,
           RelocInfo::kNoPosition);
       descriptor.initialization_pos = parameter.initializer->position();
       initializer_position = parameter.initializer_end_position;
-    } else if (parameter.is_rest) {
-      // $rest = [];
-      // for (var $argument_index = $rest_index;
-      //      $argument_index < %_ArgumentsLength();
-      //      ++$argument_index) {
-      //   %AppendElement($rest, %_Arguments($argument_index));
-      // }
-      // let <param> = $rest;
-      DCHECK(parameter.pattern->IsVariableProxy());
-      DCHECK_EQ(i, parameters.params.length() - 1);
-
-      Variable* temp_var = parameters.scope->parameter(i);
-      auto empty_values = new (zone()) ZoneList<Expression*>(0, zone());
-      auto empty_array = factory()->NewArrayLiteral(
-          empty_values, parameters.rest_array_literal_index,
-          is_strong(language_mode()), RelocInfo::kNoPosition);
-
-      auto init_array = factory()->NewAssignment(
-          Token::INIT, factory()->NewVariableProxy(temp_var), empty_array,
-          RelocInfo::kNoPosition);
-
-      auto loop = factory()->NewForStatement(NULL, RelocInfo::kNoPosition);
-
-      auto argument_index =
-          parameters.scope->NewTemporary(ast_value_factory()->empty_string());
-      auto init = factory()->NewExpressionStatement(
-          factory()->NewAssignment(
-              Token::INIT, factory()->NewVariableProxy(argument_index),
-              factory()->NewSmiLiteral(i, RelocInfo::kNoPosition),
-              RelocInfo::kNoPosition),
-          RelocInfo::kNoPosition);
-
-      auto empty_arguments = new (zone()) ZoneList<Expression*>(0, zone());
-
-      // $arguments_index < arguments.length
-      auto cond = factory()->NewCompareOperation(
-          Token::LT, factory()->NewVariableProxy(argument_index),
-          factory()->NewCallRuntime(Runtime::kInlineArgumentsLength,
-                                    empty_arguments, RelocInfo::kNoPosition),
-          RelocInfo::kNoPosition);
-
-      // ++argument_index
-      auto next = factory()->NewExpressionStatement(
-          factory()->NewCountOperation(
-              Token::INC, true, factory()->NewVariableProxy(argument_index),
-              RelocInfo::kNoPosition),
-          RelocInfo::kNoPosition);
-
-      // %_Arguments($arguments_index)
-      auto arguments_args = new (zone()) ZoneList<Expression*>(1, zone());
-      arguments_args->Add(factory()->NewVariableProxy(argument_index), zone());
-
-      // %AppendElement($rest, %_Arguments($arguments_index))
-      auto append_element_args = new (zone()) ZoneList<Expression*>(2, zone());
-
-      append_element_args->Add(factory()->NewVariableProxy(temp_var), zone());
-      append_element_args->Add(
-          factory()->NewCallRuntime(Runtime::kInlineArguments, arguments_args,
-                                    RelocInfo::kNoPosition),
-          zone());
-
-      auto body = factory()->NewExpressionStatement(
-          factory()->NewCallRuntime(Runtime::kAppendElement,
-                                    append_element_args,
-                                    RelocInfo::kNoPosition),
-          RelocInfo::kNoPosition);
-
-      loop->Initialize(init, cond, next, body);
-
-      init_block->statements()->Add(
-          factory()->NewExpressionStatement(init_array, RelocInfo::kNoPosition),
-          zone());
-
-      init_block->statements()->Add(loop, zone());
     }
 
     Scope* param_scope = scope_;
     Block* param_block = init_block;
     if (!parameter.is_simple() && scope_->calls_sloppy_eval()) {
       param_scope = NewScope(scope_, BLOCK_SCOPE);
       param_scope->set_is_declaration_scope();
       param_scope->set_start_position(parameter.pattern->position());
       param_scope->set_end_position(RelocInfo::kNoPosition);
       param_scope->RecordEvalCall();
@@ skipping 1836 matching lines @@
 
 void ParserTraits::QueueDestructuringAssignmentForRewriting(Expression* expr) {
   DCHECK(expr->IsRewritableAssignmentExpression());
   parser_->function_state_->AddDestructuringAssignment(
       Parser::DestructuringAssignment(expr, parser_->scope_));
 }
 
 
 }  // namespace internal
 }  // namespace v8