[builtins] TurboFan version of Array.prototype.forEach including fast path for FAST_ELEMENTS

src/js/array.js

 // 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.
 
 (function(global, utils, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 1502 matching lines @@
 
 %FunctionSetLength(ArrayFrom, 1);
 
 // Set up non-enumerable functions on the Array object.
 utils.InstallFunctions(GlobalArray, DONT_ENUM, [
   "from", ArrayFrom,
   "of", ArrayOf
 ]);
 
 var specialFunctions = %SpecialArrayFunctions();
+var specialExperimentalArrayFunctions = null;
 
 function getFunction(name, jsBuiltin, len) {
   var f = jsBuiltin;
   if (specialFunctions.hasOwnProperty(name)) {
     f = specialFunctions[name];
+  } else if (specialExperimentalArrayFunctions != null &&
+             specialExperimentalArrayFunctions.hasOwnProperty(name)) {
+    f = specialExperimentalArrayFunctions[name];
   }
   if (!IS_UNDEFINED(len)) {
     %FunctionSetLength(f, len);
   }
   return f;
 };
 
 var ArrayValues = getFunction("values", null, 0);
 
 // Set up non-enumerable functions of the Array.prototype object and
 // set their names.
 // Manipulate the length of some of the functions to meet
 // expectations set by ECMA-262 or Mozilla.
 utils.InstallFunctions(GlobalArray.prototype, DONT_ENUM, [
   "toString", getFunction("toString", ArrayToString),
   "toLocaleString", getFunction("toLocaleString", ArrayToLocaleString),
   "join", getFunction("join", ArrayJoin),
   "pop", getFunction("pop", ArrayPop),
   "push", getFunction("push", ArrayPush, 1),
   "reverse", getFunction("reverse", ArrayReverse),
   "shift", getFunction("shift", ArrayShift),
   "unshift", getFunction("unshift", ArrayUnshift, 1),
   "slice", getFunction("slice", ArraySlice, 2),
   "splice", getFunction("splice", ArraySplice, 2),
   "sort", getFunction("sort", ArraySort),
   "filter", getFunction("filter", ArrayFilter, 1),
-  "forEach", getFunction("forEach", ArrayForEach, 1),
   "some", getFunction("some", ArraySome, 1),
   "every", getFunction("every", ArrayEvery, 1),
   "map", getFunction("map", ArrayMap, 1),
   "indexOf", getFunction("indexOf", null, 1),
   "lastIndexOf", getFunction("lastIndexOf", ArrayLastIndexOf, 1),
   "reduce", getFunction("reduce", ArrayReduce, 1),
   "reduceRight", getFunction("reduceRight", ArrayReduceRight, 1),
   "copyWithin", getFunction("copyWithin", ArrayCopyWithin, 2),
   "find", getFunction("find", ArrayFind, 1),
   "findIndex", getFunction("findIndex", ArrayFindIndex, 1),
   "fill", getFunction("fill", ArrayFill, 1),
   "includes", getFunction("includes", null, 1),
   "keys", getFunction("keys", null, 0),
   "entries", getFunction("entries", null, 0),
   iteratorSymbol, ArrayValues
 ]);
 
+%FunctionRemovePrototype(ArrayForEach);
+
+var specialExperimentalArrayFunctions = null;
+
+function InstallExperimentalArrayFunctions() {
+  specialExperimentalArrayFunctions = %SpecialExperimentalArrayFunctions();

[Yang, 2017/02/02 10:04:58]

Can we have all of this in C++, in the bootstrapper?
See InitializeExperimentalGlobal. For an example, see
InitializeGlobal_harmony_sharedarraybuffer. That code is run after deserializing
the snapshot and can act on flags at runtime.

You would simply get the Array prototype from the global object, and install a
different built-in.

And please make sure the initial_array_prototype on the context is up-to-date
after you overwrite forEach.

[danno, 2017/02/02 17:15:48]

Done.

+  utils.InstallFunctions(global.Array.prototype, DONT_ENUM, [
+    "forEach", getFunction("forEach", ArrayForEach, 1),
+  ], false);
+}
+
 %FunctionSetName(ArrayValues, "values");
 
 %FinishArrayPrototypeSetup(GlobalArray.prototype);
 
 // The internal Array prototype doesn't need to be fancy, since it's never
 // exposed to user code.
 // Adding only the functions that are actually used.
 utils.SetUpLockedPrototype(InternalArray, GlobalArray(), [
   "indexOf", getFunction("indexOf", null),
   "join", getFunction("join", ArrayJoin),
@@ skipping 22 matching lines @@
   "slice", getFunction("slice", ArraySlice)
 ]);
 
 // -------------------------------------------------------------------
 // Exports
 
 utils.Export(function(to) {
   to.ArrayFrom = ArrayFrom;
   to.ArrayJoin = ArrayJoin;
   to.ArrayPush = ArrayPush;
+  to.InstallExperimentalArrayFunctions = InstallExperimentalArrayFunctions;
   to.ArrayToString = ArrayToString;
   to.ArrayValues = ArrayValues;
   to.InnerArrayCopyWithin = InnerArrayCopyWithin;
   to.InnerArrayEvery = InnerArrayEvery;
   to.InnerArrayFill = InnerArrayFill;
   to.InnerArrayFilter = InnerArrayFilter;
   to.InnerArrayFind = InnerArrayFind;
   to.InnerArrayFindIndex = InnerArrayFindIndex;
   to.InnerArrayForEach = InnerArrayForEach;
   to.InnerArrayJoin = InnerArrayJoin;
@@ skipping 10 matching lines @@
   "array_pop", ArrayPop,
   "array_push", ArrayPush,
   "array_shift", ArrayShift,
   "array_splice", ArraySplice,
   "array_slice", ArraySlice,
   "array_unshift", ArrayUnshift,
   "array_values_iterator", ArrayValues,
 ]);
 
 });