Fastpath some spread-call desugaring.

src/builtins/builtins-array.cc

 // Copyright 2016 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/builtins/builtins.h"
 #include "src/builtins/builtins-utils.h"
 
 #include "src/code-factory.h"
 #include "src/contexts.h"
 #include "src/elements.h"
@@ skipping 2229 matching lines @@
           elements, index, MachineType::Float64(), 0,
           CodeStubAssembler::SMI_PARAMETERS);
       var_value.Bind(assembler->AllocateHeapNumberWithValue(value));
       assembler->Goto(&allocate_entry_if_needed);
     }
 
     assembler->Bind(&holey_object_values);
     {
       // Check the array_protector cell, and take the slow path if it's invalid.
       Node* invalid =
-          assembler->SmiConstant(Smi::FromInt(Isolate::kArrayProtectorInvalid));
+          assembler->SmiConstant(Smi::FromInt(Isolate::kProtectorInvalid));
       Node* cell = assembler->LoadRoot(Heap::kArrayProtectorRootIndex);
       Node* cell_value =
           assembler->LoadObjectField(cell, PropertyCell::kValueOffset);
       assembler->GotoIf(assembler->WordEqual(cell_value, invalid),
                         &generic_values);
 
       var_value.Bind(assembler->UndefinedConstant());
       Node* value = assembler->LoadFixedArrayElement(
           elements, index, 0, CodeStubAssembler::SMI_PARAMETERS);
       assembler->GotoIf(
           assembler->WordEqual(value, assembler->TheHoleConstant()),
           &allocate_entry_if_needed);
       var_value.Bind(value);
       assembler->Goto(&allocate_entry_if_needed);
     }
 
     assembler->Bind(&holey_double_values);
     {
       // Check the array_protector cell, and take the slow path if it's invalid.
       Node* invalid =
-          assembler->SmiConstant(Smi::FromInt(Isolate::kArrayProtectorInvalid));
+          assembler->SmiConstant(Smi::FromInt(Isolate::kProtectorInvalid));
       Node* cell = assembler->LoadRoot(Heap::kArrayProtectorRootIndex);
       Node* cell_value =
           assembler->LoadObjectField(cell, PropertyCell::kValueOffset);
       assembler->GotoIf(assembler->WordEqual(cell_value, invalid),
                         &generic_values);
 
       var_value.Bind(assembler->UndefinedConstant());
       Node* value = assembler->LoadFixedDoubleArrayElement(
           elements, index, MachineType::Float64(), 0,
           CodeStubAssembler::SMI_PARAMETERS, &allocate_entry_if_needed);
@@ skipping 49 matching lines @@
             assembler->StoreObjectFieldNoWriteBarrier(
                 iterator, JSArrayIterator::kIteratedObjectMapOffset,
                 assembler->UndefinedConstant());
             assembler->GotoIf(
                 assembler->Uint32LessThanOrEqual(
                     instance_type, assembler->Int32Constant(
                                        JS_GENERIC_ARRAY_KEY_ITERATOR_TYPE)),
                 &done);
 
             Node* invalid = assembler->SmiConstant(
-                Smi::FromInt(Isolate::kArrayProtectorInvalid));
+                Smi::FromInt(Isolate::kProtectorInvalid));
             Node* cell = assembler->LoadRoot(
                 Heap::kFastArrayIterationProtectorRootIndex);
             assembler->StoreObjectFieldNoWriteBarrier(cell, Cell::kValueOffset,
                                                       invalid);
             assembler->Goto(&done);
           }
         }
 
         assembler->Bind(&if_isnotarray);
         {
@@ skipping 263 matching lines @@
         Runtime::kThrowIncompatibleMethodReceiver, context,
         assembler->HeapConstant(assembler->factory()->NewStringFromAsciiChecked(
             "Array Iterator.prototype.next", TENURED)),
         iterator);
     assembler->Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8