Array sort update - return to Native Implementation (chakra-core#6852)

Update Array.prototype.sort and TypedArray.prototype.sort implementation for spec changes.

1. Removed existing JsBuiltin Array.prototype.sort implementation
2. Rewrote native Array.prototype.sort implementation in JavascriptArray.cpp to be stable using an Insertion sort for short arrays and merge sort for longer arrays.
3. Incorporated recent spec changes including copying the array to a "List" before sorting.
4. Following the defunct previous native implementation, an Array Sort without a compare method converts the array into structs of string & value pairs to optimise the use of the string comparison the spec requires.
5. To avoid duplicating code, updated the TypedArray.prototype.sort to use the same sort implementation, this required defining CompareVarsInfo struct in the JavascriptArray.h header so it's accessible from TypedArray.cpp, also a helper method TypedArraySort is implemented within JavascriptArray.cpp in order to ensure instantiation of the correct versions of the template sort methods
6. Various clean ups and corrects to the test suite to ensure elements of the new spec are being tested
7. Also deleted some defunct comments and fixed an unrelated compile error affecting a new version of macOS

Author: rhuanjl

lib/Common/Memory/RecyclerObjectGraphDumper.cpp

@@ -1,5 +1,6 @@
 //-------------------------------------------------------------------------------------------------------
 // Copyright (C) Microsoft. All rights reserved.
+// Copyright (c) ChakraCore Project Contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 #include "CommonMemoryPch.h"
@@ -58,7 +59,7 @@ void RecyclerObjectGraphDumper::BeginDumpObject(void * objectAddress)
         {
             Assert(false);
             this->dumpObjectTypeInfo = nullptr;
-            this->dumpObjectIsArray = nullptr;
+            this->dumpObjectIsArray = false;
         }
     }
 #endif

lib/Runtime/ByteCode/ByteCodeCacheReleaseFileVersion.h

@@ -6,7 +6,7 @@
 // NOTE: If there is a merge conflict the correct fix is to make a new GUID.
 // This file was generated with tools/regenByteCode.py
 
-// {5659e34b-2f03-4880-bed4-7a688cd73df1}
+// {d31c196c-a985-4c41-a9b3-5a895b7dc567}
 const GUID byteCodeCacheReleaseFileVersion =
-{ 0x5659e34b, 0x2f03, 0x4880, {0xbe, 0xd4, 0x7a, 0x68, 0x8c, 0xd7, 0x3d, 0xf1 } };
+{ 0xd31c196c, 0xa985, 0x4c41, {0xa9, 0xb3, 0x5a, 0x89, 0x5b, 0x7d, 0xc5, 0x67 } };
 

lib/Runtime/Library/InJavascript/Array_prototype.js

@@ -169,141 +169,6 @@
         }
     });
 
-    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("DefaultSortCompare", function(left, right) {
-        // only have to handle the less than case due to the logic of the sort
-        return `${left}` < `${right}` ? -1 : 0;
-    });
-
-    platform.registerFunction('sort', function (compareFn) {
-        //#sec-array.prototype.sort
-        if (compareFn !== undefined) {
-            if (typeof compareFn !== "function") {
-                __chakraLibrary.raiseFunctionArgument_NeedFunction("Array.prototype.sort");
-            }
-        } else {
-            compareFn = __chakraLibrary.DefaultSortCompare;
-        }
-
-        const {o, len} = __chakraLibrary.CheckArrayAndGetLen(this, "Array.prototype.sort");
-        const buffer = [];
-        buffer.__proto__ = null;
-
-        // check for if the array has any missing values
-        // also pull in any values from the prototype
-        let length = 0, undefinedCount = 0;
-        for (let i = 0; i < len; ++i) {
-            if (i in o) {
-                const temp = o[i];
-                if (temp !== undefined) {
-                    buffer[length++] = o[i];
-                } else {
-                    ++undefinedCount;
-                }
-            }
-        }
-
-        if (length < 2048) {
-            let sortedCount = 1, lowerBound = 0, insertPoint = 0, upperBound = 0;
-            while (sortedCount < length) {
-                const item = buffer[sortedCount];
-                upperBound = sortedCount;
-                insertPoint = sortedCount - 1; // this lets us check for already ordered first
-                lowerBound = 0;
-                for (;;) {
-                    if (compareFn (item, buffer[insertPoint]) < 0) {
-                        upperBound = insertPoint;
-                    } else {
-                        lowerBound = insertPoint + 1;
-                    }
-                    if (lowerBound >= upperBound) {
-                        break;
-                    }
-                    insertPoint = lowerBound + (upperBound - lowerBound >> 1);
-                }
-                insertPoint = sortedCount;
-                while (insertPoint > lowerBound) {
-                    buffer[insertPoint--] = buffer[insertPoint];
-                }
-                buffer[lowerBound] = item;
-                ++sortedCount;
-            }
-        } else {
-            __chakraLibrary.MergeSort(buffer, length, compareFn);
-        }
-
-        let i = 0;
-        for (; i < length; ++i)
-        {
-            o[i] = buffer[i];
-        }
-        for (let j = 0; j < undefinedCount; ++j)
-        {
-            o[i++] = undefined;
-        }
-        for (; i < len; ++i)
-        {
-            delete o[i];
-        }
-
-        return o;
-    });
-
     platform.registerFunction('filter', function (callbackfn, thisArg = undefined) {
         // ECMAScript 2017 #sec-array.prototype.filter