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

src/runtime/runtime-array.cc

 // Copyright 2014 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/runtime/runtime-utils.h"
 
 #include "src/arguments.h"
 #include "src/code-stubs.h"
 #include "src/conversions-inl.h"
 #include "src/elements.h"
@@ skipping 617 matching lines @@
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, element_k,
                                          Object::GetProperty(&it));
       if (search_element->StrictEquals(*element_k)) {
         return *index_obj;
       }
     }
   }
   return Smi::FromInt(-1);
 }
 
-RUNTIME_FUNCTION(Runtime_SpreadIterablePrepare) {
-  HandleScope scope(isolate);
-  DCHECK_EQ(1, args.length());
-  CONVERT_ARG_HANDLE_CHECKED(Object, spread, 0);
+namespace {
 
+bool MustIterate(Isolate* isolate, Handle<Object> spread) {
   if (spread->IsJSArray()) {
     // Check that the spread arg has fast elements
     Handle<JSArray> spread_array = Handle<JSArray>::cast(spread);
     ElementsKind array_kind = spread_array->GetElementsKind();
 
     // And that it has the orignal ArrayPrototype
     JSObject* array_proto = JSObject::cast(spread_array->map()->prototype());
     Map* iterator_map = isolate->initial_array_iterator_prototype()->map();
 
     // Check that the iterator acts as expected.
     // If IsArrayIteratorLookupChainIntact(), then we know that the initial
     // ArrayIterator is being used. If the map of the prototype has changed,
     // then take the slow path.
-
     if (isolate->is_initial_array_prototype(array_proto) &&
         isolate->IsArrayIteratorLookupChainIntact() &&
         isolate->is_initial_array_iterator_prototype_map(iterator_map)) {
       if (IsFastPackedElementsKind(array_kind)) {
-        return *spread;
+        return false;
       }
       if (IsFastHoleyElementsKind(array_kind) &&
           isolate->IsFastArrayConstructorPrototypeChainIntact()) {
-        return *spread;
+        return false;
       }
     }
   }
+  return true;
+}
+
+}  //  namespace
+
+RUNTIME_FUNCTION(Runtime_SpreadIterablePrepare) {
+  HandleScope scope(isolate);
+  DCHECK_EQ(1, args.length());
+  CONVERT_ARG_HANDLE_CHECKED(Object, spread, 0);
+
+  if (!MustIterate(isolate, spread)) {
+    return *spread;
+  }
 
   Handle<JSFunction> spread_iterable_function = isolate->spread_iterable();
 
   Handle<Object> spreaded;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, spreaded,
       Execution::Call(isolate, spread_iterable_function,
                       isolate->factory()->undefined_value(), 1, &spread));
 
   return *spreaded;
 }
 
+RUNTIME_FUNCTION(Runtime_SpreadIterablePrepareVarargs) {
+  HandleScope scope(isolate);
+  DCHECK_LE(2, args.length());
+  CONVERT_ARG_HANDLE_CHECKED(Object, spread, args.length() - 1);
+
+  Handle<FixedArray> result = isolate->factory()->NewFixedArray(args.length());
+  for (int i = 0; i < args.length() - 1; i++) {
+    result->set(i, *args.at<Object>(i));
+  }
+  // Iterate over the spread if we need to.
+  if (MustIterate(isolate, spread)) {
+    Handle<JSFunction> spread_iterable_function = isolate->spread_iterable();
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+        isolate, spread,
+        Execution::Call(isolate, spread_iterable_function,
+                        isolate->factory()->undefined_value(), 1, &spread));
+  }
+  JSArray* spread_array = JSArray::cast(*spread);
+  uint32_t length;
+  CHECK(spread_array->length()->ToArrayIndex(&length));
+  for (uint32_t i = 0; i < length; i++) {
+    LookupIterator it(isolate, spread, i);
+    result = FixedArray::SetAndGrow(result, args.length() - 1 + i,
+                                    spread_array->GetDataProperty(&it));
+  }
+
+  Handle<JSArray> r = isolate->factory()->NewJSArrayWithElements(
+      result, FAST_ELEMENTS, args.length() - 1 + length);
+  return *r;
+}
+
 }  // namespace internal
 }  // namespace v8