Merge branch 'master' into FixCharTrieClone

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