Move desugaring of super calls with trailing spread to one runtime call.

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-info.h"
@@ skipping 2468 matching lines @@
   RegisterAllocationScope register_scope(this);
   SuperCallReference* super = expr->expression()->AsSuperCallReference();
 
   // Prepare the constructor to the super call.
   Register this_function = VisitForRegisterValue(super->this_function_var());
   builder()->CallRuntime(Runtime::kInlineGetSuperConstructor, this_function);
 
   Register constructor = this_function;  // Re-use dead this_function register.
   builder()->StoreAccumulatorInRegister(constructor);
 
-  RegisterList args =
-      register_allocator()->NewRegisterList(expr->arguments()->length());
-  VisitArguments(expr->arguments(), args);
+  ZoneList<Expression*>* args = expr->arguments();
 
-  // The new target is loaded into the accumulator from the
-  // {new.target} variable.
-  VisitForAccumulatorValue(super->new_target_var());
+  bool has_spread = false;
+  for (int i = 0; i < args->length(); i++) {
+    if (args->at(i)->IsSpread()) has_spread = true;
+  }
 
-  // Call construct.
-  builder()->SetExpressionPosition(expr);
-  // TODO(turbofan): For now we do gather feedback on super constructor
-  // calls, utilizing the existing machinery to inline the actual call
-  // target and the JSCreate for the implicit receiver allocation. This
-  // is not an ideal solution for super constructor calls, but it gets
-  // the job done for now. In the long run we might want to revisit this
-  // and come up with a better way.
-  int const feedback_slot_index = feedback_index(expr->CallFeedbackICSlot());
-  builder()->New(constructor, args, feedback_slot_index);
+  if (has_spread) {
+    // Deal with the spread arg.

[rmcilroy, 2016/11/30 14:35:32]

nit - Prepare the spread arguments. ?

[petermarshall, 2016/11/30 15:24:48]

Done

+    RegisterList spread_prepare_args =
+        register_allocator()->NewRegisterList(args->length());
+    VisitArguments(args, spread_prepare_args);
+
+    Runtime::FunctionId function_id = Runtime::kSpreadIterablePrepareVarargs;

[rmcilroy, 2016/11/30 14:35:32]

nit - no need for the function_id variable now

[petermarshall, 2016/11/30 15:24:48]

Done

+    builder()->CallRuntime(function_id, spread_prepare_args);
+
+    // Do ReflectConstruct.

[rmcilroy, 2016/11/30 14:35:32]

nit - Call ReflectConstruct to do the actual super constructor call.  ?

[petermarshall, 2016/11/30 15:24:48]

Done.

+    RegisterList reflect_construct_args =
+        register_allocator()->NewRegisterList(4);
+    builder()->StoreAccumulatorInRegister(reflect_construct_args[2]);
+    Register receiver = reflect_construct_args[0];

[rmcilroy, 2016/11/30 14:35:32]

nit - I'd prefer that the code just consistently uses reflect_construct_args[0],
if it isn't going to be used for anything other than the runtime call.

Also, you coul use the builder chaining for builder calls :

 builder()->StoreAccumulatorInRegister(reflect_construct_args[2])
    .LoadUndefined()
    .StoreAccumulatorInRegister(reflect_construct_args[0])
    .MoveRegister(constructor, reflect_construct_args[1]);

[petermarshall, 2016/11/30 15:24:48]

Done

+    builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
+    builder()->MoveRegister(constructor, reflect_construct_args[1]);
+    VisitForRegisterValue(super->new_target_var(), reflect_construct_args[3]);
+    builder()->CallJSRuntime(Context::REFLECT_CONSTRUCT_INDEX,
+                             reflect_construct_args);
+  } else {
+    RegisterList args_regs =
+        register_allocator()->NewRegisterList(args->length());
+    VisitArguments(args, args_regs);
+    // The new target is loaded into the accumulator from the
+    // {new.target} variable.
+    VisitForAccumulatorValue(super->new_target_var());
+
+    // Call construct.
+    builder()->SetExpressionPosition(expr);
+    // TODO(turbofan): For now we do gather feedback on super constructor
+    // calls, utilizing the existing machinery to inline the actual call
+    // target and the JSCreate for the implicit receiver allocation. This
+    // is not an ideal solution for super constructor calls, but it gets
+    // the job done for now. In the long run we might want to revisit this
+    // and come up with a better way.
+    int const feedback_slot_index = feedback_index(expr->CallFeedbackICSlot());
+    builder()->New(constructor, args_regs, feedback_slot_index);
+  }
 }
 
 void BytecodeGenerator::VisitCallNew(CallNew* expr) {
   Register constructor = VisitForRegisterValue(expr->expression());
   RegisterList args =
       register_allocator()->NewRegisterList(expr->arguments()->length());
   VisitArguments(expr->arguments(), args);
 
   builder()->SetExpressionPosition(expr);
   // The accumulator holds new target which is the same as the
@@ skipping 287 matching lines @@
 
 void BytecodeGenerator::VisitArithmeticExpression(BinaryOperation* expr) {
   // TODO(rmcilroy): Special case "x * 1.0" and "x * -1" which are generated for
   // +x and -x by the parser.
   Register lhs = VisitForRegisterValue(expr->left());
   VisitForAccumulatorValue(expr->right());
   FeedbackVectorSlot slot = expr->BinaryOperationFeedbackSlot();
   builder()->BinaryOperation(expr->op(), lhs, feedback_index(slot));
 }
 
-void BytecodeGenerator::VisitSpread(Spread* expr) { UNREACHABLE(); }
+void BytecodeGenerator::VisitSpread(Spread* expr) { Visit(expr->expression()); }
 
 void BytecodeGenerator::VisitEmptyParentheses(EmptyParentheses* expr) {
   UNREACHABLE();
 }
 
 void BytecodeGenerator::VisitThisFunction(ThisFunction* expr) {
   builder()->LoadAccumulatorWithRegister(Register::function_closure());
 }
 
 void BytecodeGenerator::VisitSuperCallReference(SuperCallReference* expr) {
@@ skipping 371 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8