Implemented Math min and max as JsBuiltIns

Author: yullin-ms

lib/Runtime/Base/JnDirectFields.h

@@ -659,6 +659,8 @@ ENTRY(Array_every)
 ENTRY(Array_includes)
 ENTRY(Array_reduce)
 ENTRY(Object_fromEntries)
+ENTRY(Math_min)
+ENTRY(Math_max)
 ENTRY(FunctionKind)
 
 // EngineInterfaceObject built-ins

lib/Runtime/Library/EngineInterfaceObjectBuiltIns.h

@@ -57,6 +57,7 @@ GlobalBuiltInConstructor(Symbol)
 GlobalMathBuiltIn(Abs)
 GlobalMathBuiltIn(Floor)
 GlobalMathBuiltIn(Max)
+GlobalMathBuiltIn(Min)
 GlobalMathBuiltIn(Pow)
 
 GlobalBuiltIn(JavascriptObject, DefineProperty)
@@ -90,6 +91,8 @@ GlobalBuiltIn(JavascriptString, Substring)
 GlobalBuiltIn(JavascriptString, Repeat)
 GlobalBuiltIn(JavascriptString, IndexOf)
 
+GlobalBuiltIn(JavascriptNumber, IsNaN)
+
 GlobalBuiltIn(GlobalObject, IsFinite) // TODO(jahorto): consider switching to Number.isFinite
 GlobalBuiltIn(GlobalObject, IsNaN) // TODO(jahorto): consider switching to Number.isNaN
 GlobalBuiltIn(GlobalObject, Eval) // TODO(jahorto): consider deleting (currently used by WinRT Promises)

lib/Runtime/Library/InJavascript/Intl.js.bc.32b.h

@@ -1876,7 +1876,6 @@ namespace Js
 
         /* No inlining            Array_Fill           */ library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::fill, &JavascriptArray::EntryInfo::Fill, 1);
         /* No inlining            Array_CopyWithin     */ library->AddFunctionToLibraryObject(arrayPrototype, PropertyIds::copyWithin, &JavascriptArray::EntryInfo::CopyWithin, 2);
-
         DebugOnly(CheckRegisteredBuiltIns(builtinFuncs, scriptContext));
 
         arrayPrototype->SetHasNoEnumerableProperties(true);
@@ -2860,6 +2859,18 @@ namespace Js
 
         Field(JavascriptFunction*)* builtinFuncs = library->GetBuiltinFunctions();
 
+#ifdef ENABLE_JS_BUILTINS
+        if (scriptContext->IsJsBuiltInEnabled())
+        {
+            library->EnsureBuiltInEngineIsReady();
+        }
+        else
+#endif
+        {
+            builtinFuncs[BuiltinFunction::Math_Max] = library->AddFunctionToLibraryObject(mathObject, PropertyIds::max, &Math::EntryInfo::Max, 2);
+            builtinFuncs[BuiltinFunction::Math_Min] = library->AddFunctionToLibraryObject(mathObject, PropertyIds::min, &Math::EntryInfo::Min, 2);
+        }
+
         builtinFuncs[BuiltinFunction::Math_Abs]    = library->AddFunctionToLibraryObject(mathObject, PropertyIds::abs,    &Math::EntryInfo::Abs,    1);
         builtinFuncs[BuiltinFunction::Math_Acos]   = library->AddFunctionToLibraryObject(mathObject, PropertyIds::acos,   &Math::EntryInfo::Acos,   1);
         builtinFuncs[BuiltinFunction::Math_Asin]   = library->AddFunctionToLibraryObject(mathObject, PropertyIds::asin,   &Math::EntryInfo::Asin,   1);
@@ -2870,8 +2881,6 @@ namespace Js
         builtinFuncs[BuiltinFunction::Math_Exp]    = library->AddFunctionToLibraryObject(mathObject, PropertyIds::exp,    &Math::EntryInfo::Exp,    1);
         builtinFuncs[BuiltinFunction::Math_Floor]  = library->AddFunctionToLibraryObject(mathObject, PropertyIds::floor,  &Math::EntryInfo::Floor,  1);
         builtinFuncs[BuiltinFunction::Math_Log]    = library->AddFunctionToLibraryObject(mathObject, PropertyIds::log,    &Math::EntryInfo::Log,    1);
-        builtinFuncs[BuiltinFunction::Math_Max]    = library->AddFunctionToLibraryObject(mathObject, PropertyIds::max,    &Math::EntryInfo::Max,    2);
-        builtinFuncs[BuiltinFunction::Math_Min]    = library->AddFunctionToLibraryObject(mathObject, PropertyIds::min,    &Math::EntryInfo::Min,    2);
         builtinFuncs[BuiltinFunction::Math_Pow]    = library->AddFunctionToLibraryObject(mathObject, PropertyIds::pow,    &Math::EntryInfo::Pow,    2);
         builtinFuncs[BuiltinFunction::Math_Random] = library->AddFunctionToLibraryObject(mathObject, PropertyIds::random, &Math::EntryInfo::Random, 0);
         builtinFuncs[BuiltinFunction::Math_Round]  = library->AddFunctionToLibraryObject(mathObject, PropertyIds::round,  &Math::EntryInfo::Round,  1);

lib/Runtime/Library/InJavascript/Intl.js.bc.64b.h

@@ -34,6 +34,9 @@
     __chakraLibrary.raiseFunctionArgument_NeedFunction = platform.raiseFunctionArgument_NeedFunction;
     __chakraLibrary.functionBind = platform.builtInJavascriptFunctionEntryBind;
     __chakraLibrary.objectDefineProperty = _objectDefineProperty;
+    __chakraLibrary.isNaN = platform.builtInGlobalObjectEntryIsNaN;
+    __chakraLibrary.positiveInfinity = platform.POSITIVE_INFINITY;
+    __chakraLibrary.negativeInfinity = platform.NEGATIVE_INFINITY;
 
     _objectDefineProperty(__chakraLibrary.ArrayIterator.prototype, 'next',
         // Object's getter and setter can get overriden on the prototype, in that case while setting the value attributes, we will end up with TypeError
@@ -595,4 +598,76 @@
         }
         return o;
     });
+
+    platform.registerFunction(platform.FunctionKind.Math_min, function (value1, value2, ...values) {
+        // #sec-math.min
+
+        // If no arguments are given, the result is positive infinity
+        // If any value is NaN, the result is NaN. 
+        // The comparison of values to determine the smallest value is done using the Abstract Relational Comparison algorithm except that +0 is considered to be larger than -0.
+        if (arguments.length === 0 ) {
+            return __chakraLibrary.positiveInfinity;
+        }
+
+        if (__chakraLibrary.isNaN(value1)) return NaN;
+        if (value1 === null) value1 = 0;
+
+        if (arguments.length === 1) {
+            return value1;
+        }
+
+        if (__chakraLibrary.isNaN(value2)) return NaN;
+        if (value2 === null) value2 = 0;
+
+        if (arguments.length === 2) {
+            if ((value1 < value2) || (value1 === value2 && value1 === 0 && 1/value1 < 1/value2)) return value1; // checks for -0 and +0
+            else return value2;
+        }
+
+        let min = value1;
+
+        for (let i = 1; i < arguments.length; i++) {
+            if (arguments[i] === null) arguments[i] = 0;
+            if (__chakraLibrary.isNaN(arguments[i])) return NaN;
+            else if ((min > arguments[i]) || (min === arguments[i] && min === 0 && 1/min > 1/arguments[i])) min = arguments[i];
+        }
+        
+        return min;
+    });
+
+    platform.registerFunction(platform.FunctionKind.Math_max, function (value1, value2, ...values) {
+        // #sec-math.max
+
+        // If no arguments are given, the result is negative infinity
+        // If any value is NaN, the result is NaN. 
+        // The comparison of values to determine the largest value is done using the Abstract Relational Comparison algorithm except that +0 is considered to be larger than -0.
+        if (arguments.length === 0) {
+            return __chakraLibrary.negativeInfinity;
+        }
+        
+        if (__chakraLibrary.isNaN(value1)) return NaN;
+        if (value1 === null) value1 = 0;
+
+        if (arguments.length === 1) {
+            return value1;
+        }
+
+        if (__chakraLibrary.isNaN(value2)) return NaN;
+        if (value2 === null) value2 = 0;
+
+        if (arguments.length === 2) {
+            if ((value1 > value2) || (value1 === value2 && value1 === 0 && 1/value1 > 1/value2)) return value1;
+            else return value2;
+        }
+
+        let max = value1;
+
+        for (let i = 1; i < arguments.length; i++) {
+            if (arguments[i] === null) arguments[i] = 0;
+            if (__chakraLibrary.isNaN(arguments[i])) return NaN;
+            else if ((max < arguments[i]) || (max === arguments[i] && max === 0 && 1/max < 1/arguments[i])) max = arguments[i]; 
+        }
+        
+        return max;
+    });
 });