Implement stable Array.prototype.sort

Author: rhuanjl

lib/Runtime/Base/JnDirectFields.h

@@ -650,6 +650,7 @@ ENTRY(Array_values)
 ENTRY(Array_keys)
 ENTRY(Array_entries)
 ENTRY(Array_indexOf)
+ENTRY(Array_sort)
 ENTRY(Array_filter)
 ENTRY(Array_flat)
 ENTRY(Array_flatMap)

lib/Runtime/Library/JavascriptLibrary.cpp

@@ -1796,7 +1796,6 @@ namespace Js
         builtinFuncs[BuiltinFunction::JavascriptArray_Reverse]            = library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::reverse,         &JavascriptArray::EntryInfo::Reverse,           0);
         builtinFuncs[BuiltinFunction::JavascriptArray_Shift]              = library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::shift,           &JavascriptArray::EntryInfo::Shift,             0);
         builtinFuncs[BuiltinFunction::JavascriptArray_Slice]              = library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::slice,           &JavascriptArray::EntryInfo::Slice,             2);
-        /* No inlining                Array_Sort               */ library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::sort,            &JavascriptArray::EntryInfo::Sort,              1);
         builtinFuncs[BuiltinFunction::JavascriptArray_Splice]             = library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::splice,          &JavascriptArray::EntryInfo::Splice,            2);
 
         // The toString and toLocaleString properties are shared between Array.prototype and %TypedArray%.prototype.
@@ -1822,6 +1821,7 @@ namespace Js
         {
             builtinFuncs[BuiltinFunction::JavascriptArray_IndexOf] = library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::indexOf, &JavascriptArray::EntryInfo::IndexOf, 1);
             builtinFuncs[BuiltinFunction::JavascriptArray_Includes] = library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::includes, &JavascriptArray::EntryInfo::Includes, 1);
+            /* No inlining                Array_Sort               */ library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::sort, &JavascriptArray::EntryInfo::Sort, 1);
         }
 
         builtinFuncs[BuiltinFunction::JavascriptArray_LastIndexOf]    = library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::lastIndexOf,     &JavascriptArray::EntryInfo::LastIndexOf,       1);

lib/Runtime/Library/JsBuiltIn/JsBuiltIn.js

@@ -174,6 +174,205 @@
         }
     });
 
+    platform.registerChakraLibraryFunction("MergeSort", function(array, length, compareFn) {
+        const buffer = [];
+        buffer.__proto__ = null;
+
+        let bucketSize = 2, lastSize = 1, position = 0;
+        const doubleLength = length + length;
+
+        while (bucketSize < doubleLength) {
+            while (position < length) {
+                const left = position;
+                const mid = left + lastSize;
+
+                // perform a merge but only if it's necessary
+                if (mid < length && compareFn(array[mid], array[mid - 1]) < 0) {
+                    let right = position + bucketSize;
+                    right = right < length ? right : length;
+                    let i = mid - 1, j = 0, k = mid;
+
+                    while (k < right) {
+                        buffer[j++] = array[k++];
+                    }
+    
+                    let rightElement = buffer[--j];
+                    let leftElement = array[i];
+
+                    for (;;) {
+                        if (compareFn(rightElement, leftElement) < 0) {
+                            array[--k] = leftElement;
+                            if (i > left) {
+                                leftElement = array[--i];
+                            } else {
+                                array[--k] = rightElement;
+                                break;
+                            }
+                        } else {
+                            array[--k] = rightElement;
+                            if (j > 0) {
+                                rightElement = buffer[--j];
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+
+                    while (j > 0) {
+                        array[--k] = buffer[--j];
+                    }
+                }  
+                position += bucketSize;
+            }
+            position = 0;
+            lastSize = bucketSize;
+            bucketSize *= 2;
+        }
+    });
+
+    platform.registerChakraLibraryFunction("DefaultStringSortCompare", function(left, right) {
+        // this version is used when the array was already strings
+        // as the sort only ever checks for < 0 on the return value of compare functions
+        // only have to handle this case
+        if (left < right) {
+            return -1;
+        }
+        return 0;
+    });
+
+    platform.registerChakraLibraryFunction("DefaultSortCompare", function(left, right) {
+        // as the sort only ever checks for < 0 on the return value of compare functions
+        // only have to handle this case
+        if (left.string < right.string) {
+            return -1;
+        }
+        return 0;
+    });
+
+    platform.registerChakraLibraryFunction("CreateCompareArray", function(array, length) {
+        let useCompareArray = false;
+        let i = 0;
+        while (i < length) {
+            if (typeof array[i++] !== "string") {
+                useCompareArray = true;
+                break;
+            }
+        }
+
+        if (useCompareArray === true) {
+            const compArray = [];
+            compArray.__proto__ = null;
+            i = 0;
+            let value;
+            while (i < length) {
+                value = array[i];
+                compArray[i++] = {
+                    value : value,
+                    string : "" + value
+                };
+            }
+            return compArray;
+        }
+        return array;
+    });
+
+    platform.registerChakraLibraryFunction("FillArrayHoles", function(array, length, offset) {
+        let i = offset, j = offset, holes = 0;
+        let value;
+        while (i < length) {
+            value = array[i];
+            if (value !== undefined) {
+                array[j++] = value;
+            } else if (!(i in array)) {
+                ++holes;
+            }
+            ++i;
+        }
+
+        const valuesLength = j;
+        const hasLength = length - holes;
+        while (j < hasLength) {
+            array[j++] = undefined;
+        }
+        while (j < length) {
+            delete array[j++];
+        }
+        return valuesLength;
+    });
+
+    platform.registerFunction(platform.FunctionKind.Array_sort, function (compareFn) {
+        //#sec-array.prototype.sort
+        if (compareFn !== undefined && typeof compareFn !== "function") {
+            __chakraLibrary.raiseFunctionArgument_NeedFunction("Array.prototype.sort");
+        }
+
+        const {o, len} = __chakraLibrary.CheckArrayAndGetLen(this, "Array.prototype.sort");
+
+        if (len < 2) { // early return if length < 2
+            return o;
+        }
+
+        // check for if the array has any missing values
+        // also pull in any values from the prototype
+        let i = 0, length = len;
+        while (i < len) {
+            if (o[i] === undefined) {
+                length = __chakraLibrary.FillArrayHoles(o, len, i);
+                break;
+            }
+            o[i] = o[i++];
+        }
+
+        let compArray = o;
+        if (compareFn === undefined && length > 1) {
+            compArray = __chakraLibrary.CreateCompareArray(o, length);
+            if (compArray === o) {
+                compareFn = __chakraLibrary.DefaultStringSortCompare;
+            } else {
+                compareFn = __chakraLibrary.DefaultSortCompare;
+            }
+        }
+
+        // for short arrays perform an insertion sort
+        if (length < 2048) {
+            let sortedCount = 1, lowerBound = 0, insertPoint = 0, upperBound = 0;
+            while (sortedCount < length) {
+                const item = compArray[sortedCount];
+                upperBound = sortedCount;
+                insertPoint = sortedCount - 1; // this lets us check for already ordered first
+                lowerBound = 0;
+                for (;;) {
+                    if (compareFn (item, compArray[insertPoint]) < 0) {
+                        upperBound = insertPoint;
+                    } else {
+                        lowerBound = insertPoint + 1;
+                    }
+                    if (lowerBound >= upperBound) {
+                        break;
+                    }
+                    insertPoint = lowerBound + (upperBound - lowerBound >> 1);
+                }
+                insertPoint = sortedCount;
+                while (insertPoint > lowerBound) {
+                    compArray[insertPoint--] = compArray[insertPoint];
+                }
+                compArray[lowerBound] = item;
+                ++sortedCount;
+            }
+        } else {
+            __chakraLibrary.MergeSort(compArray, length, compareFn);
+        }
+
+        if (compArray !== o) {
+            i = 0;
+            while (i < length) {
+                o[i] = compArray[i++].value;
+            }
+        }
+
+        return o;
+    });
+
     platform.registerFunction(platform.FunctionKind.Array_filter, function (callbackfn, thisArg = undefined) {
         // ECMAScript 2017 #sec-array.prototype.filter
 

lib/Runtime/Library/JsBuiltInEngineInterfaceExtensionObject.cpp

@@ -49,6 +49,7 @@ VALUE(Array, flat, Prototype) \
 VALUE(Array, flatMap, Prototype) \
 VALUE(Array, forEach, Prototype) \
 VALUE(Array, some, Prototype) \
+VALUE(Array, sort, Prototype) \
 VALUE(Array, every, Prototype) \
 VALUE(Array, includes, Prototype) \
 VALUE(Array, reduce, Prototype) \
@@ -391,6 +392,7 @@ FUNCTIONKIND_VALUES(VALUE)
             library->AddMember(scriptContext->GetLibrary()->GetEngineInterfaceObject()->GetCommonNativeInterfaces(), PropertyIds::builtInMathMin, func);
             break;
         // FunctionKinds with no entry functions
+        case FunctionKind::Array_sort:
         case FunctionKind::Array_flat:
         case FunctionKind::Array_flatMap:
         case FunctionKind::Object_fromEntries: