array.prototype.flat AND array.prototype.flatMap

Author: rhuanjl

lib/Parser/rterrors.h

@@ -302,7 +302,8 @@ RT_ERROR_MSG(JSERROR_SetPrototypeOf, 5616, "Failed to set prototype", "Failed to
 RT_ERROR_MSG(JSERR_ObjectIsNotInitialized, 5617, "%s: Object internal state is not initialized", "Object internal state is not initialized", kjstTypeError, 0)
 
 RT_ERROR_MSG(JSERR_GeneratorAlreadyExecuting, 5618, "%s: Cannot execute generator function because it is currently executing", "", kjstTypeError, 0)
-// 5619-5626 Unused
+RT_ERROR_MSG(JSERR_LengthIsTooBig, 5619, "Length property would exceed maximum value in output from '%s'", "", kjstTypeError, 0)
+// 5620-5626 Unused
 RT_ERROR_MSG(JSERR_NeedConstructor, 5627, "'%s' is not a constructor", "Constructor expected", kjstTypeError, 0)
 
 RT_ERROR_MSG(VBSERR_CantDisplayDate, 32812, "", "The specified date is not available in the current locale's calendar", kjstRangeError, 0)

lib/Runtime/Base/JnDirectFields.h

@@ -140,6 +140,8 @@ ENTRY(every)
 ENTRY(exec)
 ENTRY2(false_, _u("false")) // "false" cannot be an identifier in C++ so using "false_" instead
 ENTRY(flags)
+ENTRY(flat)
+ENTRY(flatMap)
 ENTRY(fill)
 ENTRY(filter)
 ENTRY(finally)
@@ -657,6 +659,7 @@ ENTRY(builtInRegexMatch)
 ENTRY(builtInCallInstanceFunction)
 ENTRY(raiseInvalidCurrencyCode)
 ENTRY(raiseInvalidDate)
+ENTRY(raiseLengthIsTooBig)
 ENTRY(raiseLocaleNotWellFormed)
 ENTRY(raiseMissingCurrencyCode)
 ENTRY(raiseNeedObject)

lib/Runtime/Library/EngineInterfaceObjectBuiltIns.h

@@ -58,6 +58,7 @@ BuiltInRaiseException1(RangeError, LocaleNotWellFormed)
 BuiltInRaiseException1(TypeError, This_NullOrUndefined)
 BuiltInRaiseException1(TypeError, NotAConstructor)
 BuiltInRaiseException1(TypeError, ObjectIsNonExtensible)
+BuiltInRaiseException1(TypeError, LengthIsTooBig)
 BuiltInRaiseException2(TypeError, NeedObjectOfType)
 BuiltInRaiseException1(RangeError, InvalidCurrencyCode)
 BuiltInRaiseException(TypeError, MissingCurrencyCode)

lib/Runtime/Library/JavascriptLibrary.cpp

@@ -1669,7 +1669,7 @@ namespace Js
 
     bool JavascriptLibrary::InitializeArrayPrototype(DynamicObject* arrayPrototype, DeferredTypeHandlerBase * typeHandler, DeferredInitializeMode mode)
     {
-        typeHandler->Convert(arrayPrototype, mode, 24);
+        typeHandler->Convert(arrayPrototype, mode, 26);
         // Note: Any new function addition/deletion/modification should also be updated in JavascriptLibrary::ProfilerRegisterArray
         // so that the update is in sync with profiler
 

lib/Runtime/Library/JsBuiltIn/JsBuiltIn.js

@@ -14,6 +14,8 @@
         ArrayEntries: { className: "Array", methodName: "entries", argumentsCount: 0, forceInline: true /*optional*/ },
         ArrayIndexOf: { className: "Array", methodName: "indexOf", argumentsCount: 1, forceInline: true /*optional*/ },
         ArrayFilter: { className: "Array", methodName: "filter", argumentsCount: 1, forceInline: true /*optional*/ },
+        ArrayFlat: { className: "Array", methodName: "flat", argumentsCount: 0, forceInline: true /*optional*/ },
+        ArrayFlatMap: { className: "Array", methodName: "flatMap", argumentsCount: 1, forceInline: true /*optional*/ },
     };
 
     var setPrototype = platform.builtInSetPrototype;
@@ -36,6 +38,7 @@
     __chakraLibrary.ArrayIterator.prototype = CreateObject(iteratorPrototype);
     __chakraLibrary.raiseNeedObjectOfType = platform.raiseNeedObjectOfType;
     __chakraLibrary.raiseThis_NullOrUndefined = platform.raiseThis_NullOrUndefined;
+    __chakraLibrary.raiseLengthIsTooBig = platform.raiseLengthIsTooBig;
     __chakraLibrary.raiseFunctionArgument_NeedFunction = platform.raiseFunctionArgument_NeedFunction;
     __chakraLibrary.callInstanceFunc = platform.builtInCallInstanceFunction;
     __chakraLibrary.functionBind = platform.builtInJavascriptFunctionEntryBind;
@@ -200,7 +203,7 @@
             len = __chakraLibrary.GetLength(o);
         }
 
-        if (typeof callbackfn != "function") {
+        if (typeof callbackfn !== "function") {
             __chakraLibrary.raiseFunctionArgument_NeedFunction("Array.prototype.filter");
         }
 
@@ -238,5 +241,178 @@
 
         return a;
     });
-  
+
+    platform.registerChakraLibraryFunction("FlattenIntoArray", function(target, source, sourceLen, start, depth)
+    {
+        // this is FlattenIntoArray from the flat/flatMap proposal BUT with no mapperFunction
+        // a seperate function has been made to handle the case where there is a mapperFunction
+        "use strict";
+        //1. Let targetIndex be start.
+        let targetIndex = start;
+        //2. Let sourceIndex be 0.
+        let sourceIndex = 0;
+        //3. Repeat, while sourceIndex < sourceLen
+        let element;
+        while (sourceIndex < sourceLen) {
+            // a. Let P be ! ToString(sourceIndex).
+            // b. Let exists be ? HasProperty(source, P).
+            if (sourceIndex in source) {
+                // c. If exists is true, then
+                //  i. Let element be ? Get(source, P).
+                element = source[sourceIndex];
+                //  ii. If mapperFunction is present - skipped see separate function
+                //  iii. Let shouldFlatten be false.
+                //  iv. If depth > 0, then
+                //      1. Set shouldFlatten to ? IsArray(element).
+                if (depth > 0 && __chakraLibrary.isArray(element)) {
+                    // v. If shouldFlatten is true, then
+                    //  1. Let elementLen be ? ToLength(? Get(element, "length")).
+                    //  2. Set targetIndex to ? FlattenIntoArray(target, element, elementLen, targetIndex, depth - 1).
+                    targetIndex = __chakraLibrary.FlattenIntoArray(target, element, __chakraLibrary.toLength(element.length), targetIndex, depth - 1);
+                } else {
+                    // vi. Else,
+                    //  1. If targetIndex >= 2^53-1, throw a TypeError exception.
+                    if (targetIndex >= 9007199254740991 /* 2^53-1 */) {
+                        __chakraLibrary.raiseLengthIsTooBig("Array.prototype.flat");
+                    }
+                    // 2. Perform ? CreateDataPropertyOrThrow(target, ! ToString(targetIndex), element).
+                    __chakraLibrary.arrayCreateDataPropertyOrThrow(target, targetIndex, element);
+                    // 3. Increase targetIndex by 1.
+                    ++targetIndex;
+                }
+            }
+            //  d. Increase sourceIndex by 1.
+            ++sourceIndex;
+        }
+        //4. Return targetIndex.
+        return targetIndex;
+    });
+
+    platform.registerChakraLibraryFunction("FlattenIntoArrayMapped", function(target, source, sourceLen, start, mapperFunction) {
+        "use strict";
+        // this is FlattenIntoArray from the flat/flatMap proposal BUT with:
+        // depth = 1 and the presence of a mapperFunction guaranteed
+        // both these conditions are always met when this is called from flatMap
+        // Additionally this is slightly refactored rather than taking a thisArg
+        // the calling function binds the thisArg if it's required
+        //1. Let targetIndex be start.
+        let targetIndex = start;
+        //2. Let sourceIndex be 0.
+        let sourceIndex = 0;
+        //3. Repeat, while sourceIndex < sourceLen
+
+        let element, innerLength, innerIndex;
+        while (sourceIndex < sourceLen) {
+            // a. Let P be ! ToString(sourceIndex).
+            // b. Let exists be ? HasProperty(source, P).
+            if (sourceIndex in source) {
+                // c. If exists is true, then
+                //  i. Let element be ? Get(source, P).
+                //  ii. If mapperFunction is present, then
+                //      1. Assert: thisArg is present.
+                //      2. Set element to ? Call(mapperFunction, thisArg , element, sourceIndex, source).
+                element = mapperFunction(source[sourceIndex], sourceIndex, source);
+                //  iii. Let shouldFlatten be false.
+                //  iv. If depth > 0, then
+                //      1. Set shouldFlatten to ? IsArray(element).
+                //  v. If shouldFlatten is true, then
+                //      1. Let elementLen be ? ToLength(? Get(element, "length")).
+                //      2. Set targetIndex to ? FlattenIntoArray(target, element, elementLen, targetIndex, depth - 1).
+                if (__chakraLibrary.isArray(element)) {
+                    // instead of calling FlattenIntoArray use a simple loop here - as depth is always 0
+                    innerLength = __chakraLibrary.toLength(element.length);
+                    innerIndex = 0;
+                    while (innerIndex < innerLength) {
+                        if (innerIndex in element) {
+                            //  1. If targetIndex >= 2^53-1, throw a TypeError exception.
+                            if (targetIndex >= 9007199254740991 /* 2^53-1 */) {
+                                __chakraLibrary.raiseLengthIsTooBig("Array.prototype.flatMap");
+                            }
+                            //  2. Perform ? CreateDataPropertyOrThrow(target, ! ToString(targetIndex), element).
+                            __chakraLibrary.arrayCreateDataPropertyOrThrow(target, targetIndex, element[innerIndex]);
+                            //  3. Increase targetIndex by 1.
+                            ++targetIndex;
+                        }
+                        ++innerIndex;
+                    }
+                } else {
+                    //  vi. Else,
+                    //      1. If targetIndex >= 2^53-1, throw a TypeError exception.
+                    if (targetIndex >= 9007199254740991 /* 2^53-1 */) {
+                        __chakraLibrary.raiseLengthIsTooBig("Array.prototype.flatMap");
+                    }
+                    //  2. Perform ? CreateDataPropertyOrThrow(target, ! ToString(targetIndex), element).
+                    __chakraLibrary.arrayCreateDataPropertyOrThrow(target, targetIndex, element);
+                    //  3. Increase targetIndex by 1.
+                    ++targetIndex;
+                }
+            }
+            //  d. Increase sourceIndex by 1.
+            ++sourceIndex;
+        }
+        //4. Return targetIndex.
+        return targetIndex;
+    });
+
+    platform.registerFunction(FunctionsEnum.ArrayFlat, function (depth) {
+        "use strict";
+        //1. Let O be ? ToObject(this value).
+        //2. Let sourceLen be ? ToLength(? Get(O, "length")).
+        let o, sourceLen;
+        
+        if (__chakraLibrary.isArray(this)) {
+            o = this;
+            sourceLen = o.length;
+        } else {
+            if (this === null || this === undefined) {
+                __chakraLibrary.raiseThis_NullOrUndefined("Array.prototype.flat");
+            }
+            o = __chakraLibrary.Object(this);
+            sourceLen =  __chakraLibrary.GetLength(o);
+        }
+        //3. Let depthNum be 1.
+        //4. If depth is not undefined, then
+        //5. Set depthNum to ? ToInteger(depth).
+        const depthNum = depth !== undefined ? __chakraLibrary.toInteger(depth) : 1;
+        //6. Let A be ? ArraySpeciesCreate(O, 0).
+        const A = __chakraLibrary.arraySpeciesCreate(o, 0);
+        //7. Perform ? FlattenIntoArray(A, O, sourceLen, 0, depthNum).
+        __chakraLibrary.FlattenIntoArray(A, o, sourceLen, 0, depthNum);
+        //8. Return A.
+        return A;
+    });
+
+    platform.registerFunction(FunctionsEnum.ArrayFlatMap, function (mapperFunction, thisArg) {
+        "use strict";
+        //1. Let O be ? ToObject(this value).
+        //2. Let sourceLen be ? ToLength(? Get(O, "length")).
+        let o, sourceLen;
+        if (__chakraLibrary.isArray(this)) {
+            o = this;
+            sourceLen = o.length;
+        } else {
+            if (this === null || this === undefined) {
+                __chakraLibrary.raiseThis_NullOrUndefined("Array.prototype.flatMap");
+            }
+            o = __chakraLibrary.Object(this);
+            sourceLen =  __chakraLibrary.GetLength(o);
+        }
+        //3. If IsCallable(mapperFunction) is false throw a TypeError exception
+        if (typeof mapperFunction !== "function") {
+            __chakraLibrary.raiseFunctionArgument_NeedFunction("Array.prototype.flatMap");
+        }
+        //4. If thisArg is present, let T be thisArg; else let T be undefined
+        //5. Let A be ? ArraySpeciesCreate(O, 0).
+        const A = __chakraLibrary.arraySpeciesCreate(o, 0);
+        //6. Perform ? FlattenIntoArray(A, O, sourceLen, 0, depthNum).
+        if (thisArg === undefined) {
+            __chakraLibrary.FlattenIntoArrayMapped(A, o, sourceLen, 0, mapperFunction);
+        } else {
+            const func = __chakraLibrary.callInstanceFunc(__chakraLibrary.functionBind, mapperFunction, thisArg);
+            __chakraLibrary.FlattenIntoArrayMapped(A, o, sourceLen, 0, func);
+        }
+        //7. Return A.
+        return A;
+    });
+
 });

test/Array/array_flat.js

@@ -0,0 +1,108 @@
+//-------------------------------------------------------------------------------------------------------
+// Copyright (C) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+//-------------------------------------------------------------------------------------------------------
+
+WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");
+
+function testFlat(input, output, depth)
+{
+    assert.areEqual(output, Array.prototype.flat.call(input, depth));
+}
+
+function testFlatMap(input, output, mappingFunction, thisArg)
+{
+    assert.areEqual(output, Array.prototype.flatMap.call(input, mappingFunction, thisArg));
+}
+
+const tests = [
+    {
+        name : "properties",
+        body : function ()
+        {
+            assert.areEqual("flat", Array.prototype.flat.name, "Array.prototype.flat name should be flat");
+            assert.areEqual("flatMap", Array.prototype.flatMap.name, "Array.prototype.flatMap name should be flatMap");
+            assert.areEqual(0, Array.prototype.flat.length, "Array.prototype.flat length should be 0");
+            assert.areEqual(1, Array.prototype.flatMap.length, "Array.prototype.flatMap length should be 1");
+        }
+    },
+    {
+        name : "flatten arrays",
+        body : function ()
+        {
+            testFlat([2, 3, [4, 5]], [2, 3, 4, 5]);
+            testFlat([2, 3, [4, [5, 6]]], [2, 3, 4, [5, 6]]);
+            testFlat([2, 3, [4, [5, 6]]], [2, 3, 4, 5, 6], 2);
+            testFlat([], []);
+            testFlat([[], [], 1], [1]);
+            const typedArr = new Int32Array(3);
+            const typedArr2 = new Int32Array(3);
+            typedArr[0] = 5;
+            typedArr[1] = 6;
+            typedArr[2] = 3;
+            typedArr2[0] = 5;
+            typedArr2[1] = 6;
+            typedArr2[2] = 3;
+            testFlat(typedArr, typedArr2);
+        }
+    },
+    {
+        name : "flatMap arrays",
+        body : function ()
+        {
+            testFlatMap([2, 3, 4, 5], [2, 4, 3, 6, 4, 8, 5, 10], function (a) { return [a, a * 2]});
+            const thisArg = { count : 0 };
+            testFlatMap([2, 3, 4], [2, 3, 3, 4, 4, 5], function (a) { this.count += a; return [ a, a + 1]}, thisArg);
+            testFlatMap([2, 3, 4], [[2], [3], [4]], function (a) { return [[a]]});
+            assert.areEqual(9, thisArg.count);
+
+            assert.throws(()=>{[2, 3].flatMap("Not Callable")});
+            assert.throws(()=>{[2, 3].flatMap(class NotCallable {})});
+        }
+    },
+    {
+        name : "flatMap abnormal this",
+        body : function ()
+        {
+            "use strict";
+            testFlatMap([2, 3], [null, null], function () { return [this]}, null);
+            testFlatMap([2, 3], [undefined, undefined], function () { return [this]}, undefined);
+            testFlatMap([2, 3], [undefined, undefined], function () { return [this]});
+            testFlatMap([2, 3], ["", ""], function () { return [this]}, "");
+            testFlatMap([2, 3], ["Test", "Test"], function () { return [this]}, "Test");
+            const boo = {};
+            testFlatMap([2, 3], [boo, boo], function () { return [this]}, boo);
+        }
+    },
+    {
+        name : "Proxied Array",
+        body : function ()
+        {
+            let getCount = 0, hasCount = 0;
+            const handler = {
+                get : function (t, p, r) { ++getCount; return Reflect.get(t, p, r); },
+                has : function (t, p, r) { ++hasCount; return Reflect.has(t, p, r); }
+            }
+            const prox = new Proxy ([2, [3, 5]], handler);
+            testFlat(prox, [2, 3, 5]);
+            assert.areEqual(4, getCount); // length and constructor are also accessed hence count 2 higher than length
+            assert.areEqual(2, hasCount);
+            const prox2 = new Proxy ([2, 3, 5], handler);
+            testFlatMap(prox2, [2, 4, 3, 6, 5, 10], function (a) { return [a, a * 2]});
+            assert.areEqual(9, getCount);  // length and constructor are also accessed hence count 2 higher than length
+            assert.areEqual(5, hasCount);
+        }
+    },
+    {
+        name : "Invalid object",
+        body : function ()
+        {
+            assert.throws(() => {Array.prototype.flat.call(null)}, TypeError);
+            assert.throws(() => {Array.prototype.flat.call(undefined)}, TypeError);
+            assert.throws(() => {Array.prototype.flatMap.call(null)}, TypeError);
+            assert.throws(() => {Array.prototype.flatMap.call(undefined)}, TypeError);
+        }
+    }
+];
+
+testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" });

test/Array/rlexe.xml

@@ -6,6 +6,14 @@
       <baseline>array_fastinit.baseline</baseline>
     </default>
   </test>
+  <test>
+    <default>
+      <files>array_flat.js</files>
+      <compile-flags>-args summary -endargs</compile-flags>
+      <!-- Lite builds don't enable JsBuiltIns hence the array flat methods won't work on them - Intl flag identifies these builds-->
+      <tags>Intl</tags>
+    </default>
+  </test>
   <test>
     <default>
       <files>array_qsortr.js</files>