Changeset 287136 in webkit for trunk/Source/JavaScriptCore/builtins

Timestamp:

Dec 16, 2021, 8:10:09 AM (4 years ago)

Author:

Devin Rousso

Message:

Implement Array.prototype.groupBy and Array.prototype.groupByToMap
​https://bugs.webkit.org/show_bug.cgi?id=234327

Reviewed by Yusuke Suzuki.

JSTests:

• stress/array-groupBy.js: Added.

(shouldBe):
(shouldBeObject):
(shouldBeObject.replacer):
(notReached):
(toObject):
(reverseInsertionOrder):

• stress/array-groupByToMap.js: Added.

(shouldBe):
(shouldBeObject):
(shouldBeObject.replacer):
(shouldBeMap):
(notReached):
(toObject):
(reverseInsertionOrder):

Source/JavaScriptCore:

Implement new Array Grouping proposal <​https://tc39.es/proposal-array-grouping/>, which just
reached Stage 3.

Array.prototype.groupBy/Array.prototype.groupByToMap will return a {}/Map where each
value in the array is put into a "bucket" keyed by the return value of the provoded callback.

`js
const array = [1, 2, 3, 4];

array.groupBy(n => n % 2 ? "odd" : "even") { odd: [1, 3], even: [2, 4] }
array.groupByToMap(n => n % 2 ? "odd" : "even") new Map("odd", [1, 3, ["even", [2, 4]])
`

• builtins/ArrayPrototype.js:

(groupBy): Added.
(groupByToMap): Added.

• runtime/ArrayPrototype.cpp:

(JSC::ArrayPrototype::finishCreation):

• bytecode/BytecodeIntrinsicRegistry.h:
• bytecompiler/NodesCodegen.cpp:

(JSC::BytecodeIntrinsicNode::emit_intrinsic_toPropertyKey): Added.
Allow @toPropertyKey to be used in builtins to convert a value to a property key. This is
used to avoid converting the return value of the callback given to groupBy more than once.

• builtins/BuiltinNames.h:
• bytecode/LinkTimeConstant.h:
• runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::init):
Allow @Map to be used in builtins to create a primordial Map instance. This is used to
avoid side effects when creating and populating the Map returned by groupByToMap.

• runtime/OptionsList.h:

Add useArrayGroupByMethod option.

Source/WebInspectorUI:

• UserInterface/Models/NativeFunctionParameters.js:

Location:

trunk/Source/JavaScriptCore/builtins

Files:

• ArrayPrototype.js (modified) (1 diff)
• BuiltinNames.h (modified) (1 diff)

trunk/Source/JavaScriptCore/builtins/ArrayPrototype.js

@@ -157 +157 @@
 }
 
+function groupBy(callback /*, thisArg */)
+{
+    var array = @toObject(this, "Array.prototype.groupBy requires that |this| not be null or undefined");
+    var length = @toLength(array.length);
+
+    if (!@isCallable(callback))
+        @throwTypeError("Array.prototype.groupBy callback must be a function");
+
+    var thisArg = @argument(1);
+
+    var groups = @Object.@create(null);
+    for (var i = 0; i < length; ++i) {
+        var value = array[i];
+        var key = @toPropertyKey(callback.@call(thisArg, value, i, array));
+        var group = groups[key];
+        if (!group) {
+            group = [];
+            @putByValDirect(groups, key, group);
+        }
+        @putByValDirect(group, group.length, value);
+    }
+    return groups;
+}
+
+function groupByToMap(callback /*, thisArg */)
+{
+    var array = @toObject(this, "Array.prototype.groupByToMap requires that |this| not be null or undefined");
+    var length = @toLength(array.length);
+
+    if (!@isCallable(callback))
+        @throwTypeError("Array.prototype.groupByToMap callback must be a function");
+
+    var thisArg = @argument(1);
+
+    var groups = new @Map;
+    for (var i = 0; i < length; ++i) {
+        var value = array[i];
+        var key = callback.@call(thisArg, value, i, array);
+        var group = groups.@get(key);
+        if (!group) {
+            group = [];
+            groups.@set(key, group);
+        }
+        @putByValDirect(group, group.length, value);
+    }
+    return groups;
+}
+
 function map(callback /*, thisArg */)
 {

trunk/Source/JavaScriptCore/builtins/BuiltinNames.h

@@ -71 +71 @@
     macro(defaultPromiseThen) \
     macro(Set) \
+    macro(Map) \
     macro(throwTypeErrorFunction) \
     macro(typedArrayLength) \