Replace flag-proven casts with Unsafe.As on hot arithmetic paths

Jint/JsValueExtensions.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -236,7 +237,8 @@ public static double AsNumber(this JsValue value)
             ThrowWrongTypeException(value, "number");
         }
 
-        return ((JsNumber) value)._value;
+        Debug.Assert(value is JsNumber);
+        return Unsafe.As<JsNumber>(value)._value;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

Jint/Runtime/Interpreter/Expressions/JintBinaryExpression.cs

@@ -1271,7 +1271,8 @@ public override bool GetBooleanValue(EvaluationContext context)
             }
 
             var value = Compare(left, right);
-            return value._type != InternalTypes.Undefined && ((JsBoolean) value)._value;
+            // Compare only ever returns JsBoolean.True/False or undefined
+            return value._type != InternalTypes.Undefined && Unsafe.As<JsBoolean>(value)._value;
         }
     }
 
@@ -1326,7 +1327,8 @@ public override bool GetBooleanValue(EvaluationContext context)
             }
 
             var value = Compare(right, left, false);
-            return value._type != InternalTypes.Undefined && ((JsBoolean) value)._value;
+            // Compare only ever returns JsBoolean.True/False or undefined
+            return value._type != InternalTypes.Undefined && Unsafe.As<JsBoolean>(value)._value;
         }
     }
 
@@ -1364,7 +1366,7 @@ protected override object EvaluateInternal(EvaluationContext context)
 
             if (left._type == InternalTypes.Number && right._type == InternalTypes.Number)
             {
-                return JsNumber.Create(((JsNumber) left)._value + ((JsNumber) right)._value);
+                return JsNumber.Create(Unsafe.As<JsNumber>(left)._value + Unsafe.As<JsNumber>(right)._value);
             }
 
             var lprim = TypeConverter.ToPrimitive(left);
@@ -1506,7 +1508,7 @@ protected override object EvaluateInternal(EvaluationContext context)
 
             if (left._type == InternalTypes.Number && right._type == InternalTypes.Number)
             {
-                return JsNumber.Create(((JsNumber) left)._value - ((JsNumber) right)._value);
+                return JsNumber.Create(Unsafe.As<JsNumber>(left)._value - Unsafe.As<JsNumber>(right)._value);
             }
 
             left = TypeConverter.ToNumeric(left);
@@ -1567,7 +1569,7 @@ protected override object EvaluateInternal(EvaluationContext context)
             }
             else if (left._type == InternalTypes.Number && right._type == InternalTypes.Number)
             {
-                result = JsNumber.Create(((JsNumber) left)._value * ((JsNumber) right)._value);
+                result = JsNumber.Create(Unsafe.As<JsNumber>(left)._value * Unsafe.As<JsNumber>(right)._value);
             }
             else
             {
@@ -1618,7 +1620,7 @@ protected override object EvaluateInternal(EvaluationContext context)
 
             if (left._type == InternalTypes.Number && right._type == InternalTypes.Number)
             {
-                return JsNumber.Create(((JsNumber) left)._value / ((JsNumber) right)._value);
+                return JsNumber.Create(Unsafe.As<JsNumber>(left)._value / Unsafe.As<JsNumber>(right)._value);
             }
 
             left = TypeConverter.ToNumeric(left);
@@ -1739,7 +1741,8 @@ protected override object EvaluateInternal(EvaluationContext context)
             var right = _leftFirst ? rightValue : leftValue;
 
             var value = Compare(left, right, _leftFirst);
-            return value.IsUndefined() || ((JsBoolean) value)._value ? JsBoolean.False : JsBoolean.True;
+            // Compare only ever returns JsBoolean.True/False or undefined
+            return value.IsUndefined() || Unsafe.As<JsBoolean>(value)._value ? JsBoolean.False : JsBoolean.True;
         }
 
         public override bool GetBooleanValue(EvaluationContext context)
@@ -1764,7 +1767,8 @@ public override bool GetBooleanValue(EvaluationContext context)
             var right = _leftFirst ? rightValue : leftValue;
 
             var value = Compare(left, right, _leftFirst);
-            return !value.IsUndefined() && !((JsBoolean) value)._value;
+            // Compare only ever returns JsBoolean.True/False or undefined
+            return !value.IsUndefined() && !Unsafe.As<JsBoolean>(value)._value;
         }
     }
 

Jint/Runtime/Interpreter/Expressions/JintExpression.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using Jint.Native;
@@ -392,6 +393,9 @@ protected static JsValue Compare(JsValue x, JsValue y, bool leftFirst = true) =>
 
     private static JsValue CompareNumber(JsValue x, JsValue y, bool leftFirst)
     {
+        // only called from Compare which has proven both operands via IsNumber()
+        Debug.Assert(x is JsNumber && y is JsNumber);
+
         if (x.IsInteger() && y.IsInteger())
         {
             return x.AsInteger() < y.AsInteger() ? JsBoolean.True : JsBoolean.False;
@@ -400,13 +404,13 @@ private static JsValue CompareNumber(JsValue x, JsValue y, bool leftFirst)
         double nx, ny;
         if (leftFirst)
         {
-            nx = ((JsNumber) x)._value;
-            ny = ((JsNumber) y)._value;
+            nx = Unsafe.As<JsNumber>(x)._value;
+            ny = Unsafe.As<JsNumber>(y)._value;
         }
         else
         {
-            ny = ((JsNumber) y)._value;
-            nx = ((JsNumber) x)._value;
+            ny = Unsafe.As<JsNumber>(y)._value;
+            nx = Unsafe.As<JsNumber>(x)._value;
         }
 
         if (double.IsNaN(nx) || double.IsNaN(ny))

Jint/Runtime/Interpreter/Expressions/JintUnaryExpression.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 using Environment = Jint.Runtime.Environments.Environment;
 
@@ -297,7 +298,7 @@ internal static JsValue EvaluateMinus(JsValue value)
         value = TypeConverter.ToNumeric(value);
         if (value.IsNumber())
         {
-            var n = ((JsNumber) value)._value;
+            var n = Unsafe.As<JsNumber>(value)._value;
             return double.IsNaN(n) ? JsNumber.DoubleNaN : JsNumber.Create(n * -1);
         }