[es6] re-implement rest parameters via desugaring

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/ast-literal-reindexer.h"
 #include "src/bailout-reason.h"
@@ skipping 2810 matching lines @@
     if (IsSubclassConstructor(function_state_->kind())) {
       // For subclass constructors we need to return this in case of undefined
       // and throw an exception in case of a non object.
       //
       //   return expr;
       //
       // Is rewritten as:
       //
       //   return (temp = expr) === undefined ? this :
       //       %_IsSpecObject(temp) ? temp : throw new TypeError(...);
-      Variable* temp = scope_->DeclarationScope()->NewTemporary(
+      Variable* temp = scope_->TempScope()->NewTemporary(
           ast_value_factory()->empty_string());
       Assignment* assign = factory()->NewAssignment(
           Token::ASSIGN, factory()->NewVariableProxy(temp), return_value, pos);
 
       Expression* throw_expression =
           NewThrowTypeError(MessageTemplate::kDerivedConstructorReturn,
                             ast_value_factory()->empty_string(), pos);
 
       // %_IsSpecObject(temp)
       ZoneList<Expression*>* is_spec_object_args =
@@ skipping 333 matching lines @@
 }
 
 
 void Parser::InitializeForEachStatement(ForEachStatement* stmt,
                                         Expression* each,
                                         Expression* subject,
                                         Statement* body) {
   ForOfStatement* for_of = stmt->AsForOfStatement();
 
   if (for_of != NULL) {
-    Variable* iterator = scope_->DeclarationScope()->NewTemporary(
+    Variable* iterator = scope_->TempScope()->NewTemporary(
         ast_value_factory()->dot_iterator_string());
-    Variable* result = scope_->DeclarationScope()->NewTemporary(
+    Variable* result = scope_->TempScope()->NewTemporary(
         ast_value_factory()->dot_result_string());
 
     Expression* assign_iterator;
     Expression* next_result;
     Expression* result_done;
     Expression* assign_each;
 
     // iterator = subject[Symbol.iterator]()
     assign_iterator = factory()->NewAssignment(
         Token::ASSIGN, factory()->NewVariableProxy(iterator),
@@ skipping 95 matching lines @@
 
   // Add statement: let/const x = i.
   outer_block->AddStatement(init, zone());
 
   const AstRawString* temp_name = ast_value_factory()->dot_for_string();
 
   // For each lexical variable x:
   //   make statement: temp_x = x.
   for (int i = 0; i < names->length(); i++) {
     VariableProxy* proxy = NewUnresolved(names->at(i), LET);
-    Variable* temp = scope_->DeclarationScope()->NewTemporary(temp_name);
+    Variable* temp = scope_->TempScope()->NewTemporary(temp_name);
     VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, temp_proxy, proxy, RelocInfo::kNoPosition);
     Statement* assignment_statement = factory()->NewExpressionStatement(
         assignment, RelocInfo::kNoPosition);
     outer_block->AddStatement(assignment_statement, zone());
     temps.Add(temp, zone());
   }
 
   Variable* first = NULL;
   // Make statement: first = 1.
   if (next) {
-    first = scope_->DeclarationScope()->NewTemporary(temp_name);
+    first = scope_->TempScope()->NewTemporary(temp_name);
     VariableProxy* first_proxy = factory()->NewVariableProxy(first);
     Expression* const1 = factory()->NewSmiLiteral(1, RelocInfo::kNoPosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, first_proxy, const1, RelocInfo::kNoPosition);
     Statement* assignment_statement =
         factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition);
     outer_block->AddStatement(assignment_statement, zone());
   }
 
   // make statement: undefined;
@@ skipping 59 matching lines @@
       Assignment* assignment = factory()->NewAssignment(
           Token::ASSIGN, first_proxy, const0, RelocInfo::kNoPosition);
       clear_first =
           factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition);
     }
     Statement* clear_first_or_next = factory()->NewIfStatement(
         compare, clear_first, next, RelocInfo::kNoPosition);
     ignore_completion_block->AddStatement(clear_first_or_next, zone());
   }
 
-  Variable* flag = scope_->DeclarationScope()->NewTemporary(temp_name);
+  Variable* flag = scope_->TempScope()->NewTemporary(temp_name);
   // Make statement: flag = 1.
   {
     VariableProxy* flag_proxy = factory()->NewVariableProxy(flag);
     Expression* const1 = factory()->NewSmiLiteral(1, RelocInfo::kNoPosition);
     Assignment* assignment = factory()->NewAssignment(
         Token::ASSIGN, flag_proxy, const1, RelocInfo::kNoPosition);
     Statement* assignment_statement =
         factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition);
     ignore_completion_block->AddStatement(assignment_statement, zone());
   }
@@ skipping 165 matching lines @@
         //   {
         //     <let x' be a temporary variable>
         //     for (x' in/of e) {
         //       let/const/var x;
         //       x = x';
         //       b;
         //     }
         //     let x;  // for TDZ
         //   }
 
-        Variable* temp = scope_->DeclarationScope()->NewTemporary(
+        Variable* temp = scope_->TempScope()->NewTemporary(
             ast_value_factory()->dot_for_string());
         ForEachStatement* loop =
             factory()->NewForEachStatement(mode, labels, stmt_pos);
         Target target(&this->target_stack_, loop);
 
         Expression* enumerable = ParseExpression(true, CHECK_OK);
 
         Expect(Token::RPAREN, CHECK_OK);
 
         Scope* body_scope = NewScope(scope_, BLOCK_SCOPE);
@@ skipping 412 matching lines @@
 
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.
       scope_->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
       // expressions. This also marks the FunctionState as a generator.
-      Variable* temp = scope_->DeclarationScope()->NewTemporary(
+      Variable* temp = scope_->TempScope()->NewTemporary(
           ast_value_factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
     Expect(Token::LPAREN, CHECK_OK);
     int start_position = scanner()->location().beg_pos;
     scope_->set_start_position(start_position);
     ParserFormalParameterParsingState parsing_state(scope);
     num_parameters =
         ParseFormalParameterList(&parsing_state, &formals_classifier, CHECK_OK);
@@ skipping 140 matching lines @@
 
   FunctionLiteral* function_literal = factory()->NewFunctionLiteral(
       function_name, ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, num_parameters,
       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()) {
-    // TODO(caitp): enable optimization of functions with rest params
-    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 111 matching lines @@
       condition, factory()->NewExpressionStatement(throw_type_error,
                                                    RelocInfo::kNoPosition),
       factory()->NewEmptyStatement(RelocInfo::kNoPosition),
       RelocInfo::kNoPosition);
   return if_statement;
 }
 
 
 bool Parser::IsSimpleParameterList(
     const ParserFormalParameterParsingState& formal_parameters) {
+  if (formal_parameters.has_rest) return false;
   for (auto parameter : formal_parameters.params) {
     if (parameter.pattern != nullptr) return false;
   }
   return true;
 }
 
 
 Block* Parser::BuildParameterInitializationBlock(
     const ParserFormalParameterParsingState& formal_parameters, bool* ok) {
   DCHECK(!IsSimpleParameterList(formal_parameters));
@@ skipping 12 matching lines @@
     descriptor.needs_init = true;
     descriptor.declaration_pos = parameter.pattern->position();
     descriptor.initialization_pos = parameter.pattern->position();
     descriptor.init_op = Token::INIT_LET;
     DeclarationParsingResult::Declaration decl(
         parameter.pattern, parameter.pattern->position(),
         factory()->NewVariableProxy(parameter.var));
     PatternRewriter::DeclareAndInitializeVariables(init_block, &descriptor,
                                                    &decl, nullptr, CHECK_OK);
   }
+  if (formal_parameters.has_rest) {
+    auto rest_parameter = formal_parameters.params.last();
+    int rest_index = formal_parameters.params.length() - 1;
+    DCHECK_NULL(rest_parameter.pattern);
+
+    // DESUGAR:
+    // let <rest_params> = [];
+    // for (int i = <rest_index>; i < <arguments.length>; ++i) {
+    //   %AddElement(<rest_params>, <rest_params.length>, arguments[i++]);
+    // }
+    VariableProxy* proxy = factory()->NewVariableProxy(rest_parameter.var);
+    Declaration* declaration = factory()->NewVariableDeclaration(
+        proxy, VAR, scope_, RelocInfo::kNoPosition);
+    Variable* var = this->Declare(declaration, DeclarationDescriptor::PARAMETER,
+                                  false, CHECK_OK);
+    proxy = factory()->NewVariableProxy(var);
+
+    // TODO(@caitp): use an array literal to avoid escaping the object and
+    // needing 2 runtime functions which do the same thing.
+    auto empty_values = new (zone()) ZoneList<Expression*>(0, zone());
+    Expression* empty_array = factory()->NewCallRuntime(
+        is_strong(language_mode())
+            ? ast_value_factory()->strong_empty_array_string()
+            : ast_value_factory()->empty_array_string(),
+        nullptr, empty_values, RelocInfo::kNoPosition);
+
+    Assignment* init_array = factory()->NewAssignment(
+        Token::INIT_VAR, proxy, empty_array, RelocInfo::kNoPosition);
+
+    auto loop = factory()->NewForStatement(NULL, RelocInfo::kNoPosition);
+
+    // argument_index = rest_index
+    Variable* argument_index =
+        scope_->NewTemporary(ast_value_factory()->dot_string());
+    auto init = factory()->NewExpressionStatement(
+        factory()->NewAssignment(
+            Token::INIT_VAR, factory()->NewVariableProxy(argument_index),
+            factory()->NewSmiLiteral(rest_index, RelocInfo::kNoPosition),
+            RelocInfo::kNoPosition),
+        RelocInfo::kNoPosition);
+
+    auto arguments_length = Runtime::FunctionForId(Runtime::kArgumentsLength);
+    auto empty_arguments = new (zone()) ZoneList<Expression*>(0, zone());
+
+    // argument_index < %_ArgumentsLength()
+    auto cond = factory()->NewCompareOperation(
+        Token::LT, factory()->NewVariableProxy(argument_index),
+        factory()->NewCallRuntime(ast_value_factory()->empty_string(),
+                                  arguments_length, 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);
+
+    auto arguments = Runtime::FunctionForId(Runtime::kArguments);
+    // %_Arguments(<argument_index>)
+    auto arguments_args = new (zone()) ZoneList<Expression*>(1, zone());
+    arguments_args->Add(factory()->NewVariableProxy(argument_index), zone());
+
+    // %AddElement(
+    //     <restParam>, <restParam.length>, %_Arguments(<argument_index>));
+    auto add_element = Runtime::FunctionForId(Runtime::kAddElement);
+    auto add_element_args = new (zone()) ZoneList<Expression*>(3, zone());
+    add_element_args->Add(factory()->NewVariableProxy(var), zone());
+    add_element_args->Add(
+        factory()->NewProperty(
+            factory()->NewVariableProxy(var),
+            factory()->NewStringLiteral(ast_value_factory()->length_string(),
+                                        RelocInfo::kNoPosition),
+            RelocInfo::kNoPosition),
+        zone());
+    add_element_args->Add(factory()->NewCallRuntime(
+                              ast_value_factory()->empty_string(), arguments,
+                              arguments_args, RelocInfo::kNoPosition),
+                          zone());
+
+    auto body = factory()->NewExpressionStatement(
+        factory()->NewCallRuntime(ast_value_factory()->empty_string(),
+                                  add_element, add_element_args,
+                                  RelocInfo::kNoPosition),
+        RelocInfo::kNoPosition);
+
+    loop->Initialize(init, cond, next, body);
+    init_block->AddStatement(
+        factory()->NewExpressionStatement(init_array, RelocInfo::kNoPosition),
+        zone());
+    init_block->AddStatement(loop, zone());
+  }
   return init_block;
 }
 
 
 ZoneList<Statement*>* Parser::ParseEagerFunctionBody(
     const AstRawString* function_name, int pos,
     const ParserFormalParameterParsingState& formal_parameters, Variable* fvar,
     Token::Value fvar_init_op, FunctionKind kind, bool* ok) {
   bool is_simple_parameter_list = IsSimpleParameterList(formal_parameters);
 
@@ skipping 1603 matching lines @@
         ast_value_factory()->reflect_construct_string(), NULL, args, pos);
   } else {
     if (function->IsProperty()) {
       // Method calls
       if (function->AsProperty()->IsSuperAccess()) {
         Expression* home =
             ThisExpression(scope_, factory(), RelocInfo::kNoPosition);
         args->InsertAt(0, function, zone());
         args->InsertAt(1, home, zone());
       } else {
-        Variable* temp =
-            scope_->NewTemporary(ast_value_factory()->empty_string());
+        Variable* temp = scope_->TempScope()->NewTemporary(
+            ast_value_factory()->empty_string());
         VariableProxy* obj = factory()->NewVariableProxy(temp);
         Assignment* assign_obj = factory()->NewAssignment(
             Token::ASSIGN, obj, function->AsProperty()->obj(),
             RelocInfo::kNoPosition);
         function = factory()->NewProperty(
             assign_obj, function->AsProperty()->key(), RelocInfo::kNoPosition);
         args->InsertAt(0, function, zone());
         obj = factory()->NewVariableProxy(temp);
         args->InsertAt(1, obj, zone());
       }
@@ skipping 12 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