Use specialized methods for comparisons

Remove the generalized `cast` in favor of 3 specialized ones.
This is a slight optimizations for comparisons.

Author: GarboMuffin

src/compiler/blocks/compiler_scratch3_operators.js

@@ -40,19 +40,19 @@ module.exports.getInputs = () => {
 const equals = /** @param {InputUtil} util */ (util) => {
     const OPERAND1 = util.input('OPERAND1');
     const OPERAND2 = util.input('OPERAND2');
-    return util.boolean(`(compare(${OPERAND1}, ${OPERAND2}) === 0)`);
+    return util.boolean(`compareEqual(${OPERAND1}, ${OPERAND2})`);
 };
 
 const greaterThan = /** @param {InputUtil} util */ (util) => {
     const OPERAND1 = util.input('OPERAND1');
     const OPERAND2 = util.input('OPERAND2');
-    return util.boolean(`(compare(${OPERAND1}, ${OPERAND2}) > 0)`);
+    return util.boolean(`compareGreaterThan(${OPERAND1}, ${OPERAND2})`);
 };
 
 const lessThan = /** @param {InputUtil} util */ (util) => {
     const OPERAND1 = util.input('OPERAND1');
     const OPERAND2 = util.input('OPERAND2');
-    return util.boolean(`(compare(${OPERAND1}, ${OPERAND2}) < 0)`);
+    return util.boolean(`compareLessThan(${OPERAND1}, ${OPERAND2})`);
 };
 
 const and = /** @param {InputUtil} util */ (util) => {
@@ -134,6 +134,7 @@ const mathop = /** @param {InputUtil} util */ (util) => {
 const random = /** @param {InputUtil} util */ (util) => {
     const FROM = util.input('FROM');
     const TO = util.input('TO');
+    // If we know the high and low values are compile-time, we can determine whether to return ints or floats at compile time.
     if (typeof FROM.constantValue !== 'undefined' && typeof TO.constantValue !== 'undefined') {
         const nFrom = Cast.toNumber(FROM.constantValue);
         const nTo = Cast.toNumber(TO.constantValue);

src/compiler/execute.js

@@ -179,16 +179,15 @@ const toBoolean = (value) => {
  */
 const isWhiteSpace = (val) => {
     return val === null || (typeof val === 'string' && val.trim().length === 0);
-}
+};
 
 /**
- * Compare two values using Scratch casting.
- * Similar to Cast.compare()
- * @param {*} v1 First value to compare.
- * @param {*} v2 Second value to compare.
- * @returns {number} Negative if v1 < v2, 0 if equal, positive if v1 > v2
+ * Determine if two values are equal.
+ * @param {*} v1
+ * @param {*} v2
+ * @returns {boolean} true if v1 is equal to v2
  */
-const compare = (v1, v2) => {
+const compareEqual = (v1, v2) => {
     let n1 = +v1;
     let n2 = +v2;
     if (n1 === 0 && isWhiteSpace(v1)) {
@@ -199,20 +198,53 @@ const compare = (v1, v2) => {
     if (isNaN(n1) || isNaN(n2)) {
         const s1 = ('' + v1).toLowerCase();
         const s2 = ('' + v2).toLowerCase();
-        if (s1 < s2) {
-            return -1;
-        } else if (s1 > s2) {
-            return 1;
-        }
-        return 0;
+        return s1 === s2;
+    }
+    return n1 === n2;
+};
+
+/**
+ * Determine if one value is greater than another.
+ * @param {*} v1
+ * @param {*} v2
+ * @returns {boolean} true if v1 is greater than v2
+ */
+const compareGreaterThan = (v1, v2) => {
+    let n1 = +v1;
+    let n2 = +v2;
+    if (n1 === 0 && isWhiteSpace(v1)) {
+        n1 = NaN;
+    } else if (n2 === 0 && isWhiteSpace(v2)) {
+        n2 = NaN;
+    }
+    if (isNaN(n1) || isNaN(n2)) {
+        const s1 = ('' + v1).toLowerCase();
+        const s2 = ('' + v2).toLowerCase();
+        return s1 > s2;
+    }
+    return n1 > n2;
+};
+
+/**
+ * Determine if one value is less than another.
+ * @param {*} v1
+ * @param {*} v2
+ * @returns {boolean} true if v1 is less than v2
+ */
+const compareLessThan = (v1, v2) => {
+    let n1 = +v1;
+    let n2 = +v2;
+    if (n1 === 0 && isWhiteSpace(v1)) {
+        n1 = NaN;
+    } else if (n2 === 0 && isWhiteSpace(v2)) {
+        n2 = NaN;
     }
-    if (
-        (n1 === Infinity && n2 === Infinity) ||
-        (n1 === -Infinity && n2 === -Infinity)
-    ) {
-        return 0;
+    if (isNaN(n1) || isNaN(n2)) {
+        const s1 = ('' + v1).toLowerCase();
+        const s2 = ('' + v2).toLowerCase();
+        return s1 < s2;
     }
-    return n1 - n2;
+    return n1 < n2;
 };
 
 /**