@grain/stdlib 0.6.4 → 0.6.5

package/runtime/numbers.gr

@@ -402,31 +402,31 @@ provide let boxedRationalDenominator = xptr => {
 
 @unsafe
 provide let coerceNumberToWasmF32 = (x: Number) => {
-  let x = WasmI32.fromGrain(x)
-  if (isSimpleNumber(x)) {
-    WasmF32.convertI32S(untagSimple(x))
+  let xVal = WasmI32.fromGrain(x)
+  let result = if (isSimpleNumber(xVal)) {
+    WasmF32.convertI32S(untagSimple(xVal))
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
-        WasmF32.convertI64S(boxedInt64Number(x))
+        WasmF32.convertI64S(boxedInt64Number(xVal))
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        BI.toFloat32(x)
+        BI.toFloat32(xVal)
       },
       t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => {
         use WasmF32.{ (/) }
-        BI.toFloat32(boxedRationalNumerator(x)) /
-          BI.toFloat32(boxedRationalDenominator(x))
+        BI.toFloat32(boxedRationalNumerator(xVal)) /
+          BI.toFloat32(boxedRationalDenominator(xVal))
       },
       t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => {
         use WasmF64.{ (<), (>) }
-        let xval = boxedFloat64Number(x)
-        if (xval > _F32_MAX || xval < _F32_MIN) {
+        let boxedVal = boxedFloat64Number(xVal)
+        if (boxedVal > _F32_MAX || boxedVal < _F32_MIN) {
           // Not an actual return value
           throw Exception.Overflow
         } else {
-          WasmF32.demoteF64(xval)
+          WasmF32.demoteF64(boxedVal)
         }
       },
       _ => {
@@ -434,50 +434,54 @@ provide let coerceNumberToWasmF32 = (x: Number) => {
       },
     }
   }
+  ignore(x)
+  result
 }
 
 @unsafe
 provide let coerceNumberToWasmF64 = (x: Number) => {
-  let x = WasmI32.fromGrain(x)
-  if (isSimpleNumber(x)) {
-    WasmF64.convertI32S(untagSimple(x))
+  let xVal = WasmI32.fromGrain(x)
+  let result = if (isSimpleNumber(xVal)) {
+    WasmF64.convertI32S(untagSimple(xVal))
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
-        WasmF64.convertI64S(boxedInt64Number(x))
+        WasmF64.convertI64S(boxedInt64Number(xVal))
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        BI.toFloat64(x)
+        BI.toFloat64(xVal)
       },
       t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => {
         use WasmF64.{ (/) }
-        BI.toFloat64(boxedRationalNumerator(x)) /
-          BI.toFloat64(boxedRationalDenominator(x))
+        BI.toFloat64(boxedRationalNumerator(xVal)) /
+          BI.toFloat64(boxedRationalDenominator(xVal))
       },
       t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => {
-        boxedFloat64Number(x)
+        boxedFloat64Number(xVal)
       },
       _ => {
         throw UnknownNumberTag
       },
     }
   }
+  ignore(x)
+  result
 }
 
 @unsafe
 provide let coerceNumberToWasmI64 = (x: Number) => {
-  let x = WasmI32.fromGrain(x)
-  if (isSimpleNumber(x)) {
-    WasmI64.extendI32S(untagSimple(x))
+  let xVal = WasmI32.fromGrain(x)
+  let result = if (isSimpleNumber(xVal)) {
+    WasmI64.extendI32S(untagSimple(xVal))
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
-        boxedInt64Number(x)
+        boxedInt64Number(xVal)
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        BI.toInt64(x)
+        BI.toInt64(xVal)
       },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
@@ -485,26 +489,28 @@ provide let coerceNumberToWasmI64 = (x: Number) => {
       },
     }
   }
+  ignore(x)
+  result
 }
 
 @unsafe
 provide let coerceNumberToWasmI32 = (x: Number) => {
   use WasmI64.{ (<), (>) }
-  let x = WasmI32.fromGrain(x)
-  if (isSimpleNumber(x)) {
-    untagSimple(x)
+  let xVal = WasmI32.fromGrain(x)
+  let result = if (isSimpleNumber(xVal)) {
+    untagSimple(xVal)
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
-        let int64 = boxedInt64Number(x)
+        let int64 = boxedInt64Number(xVal)
         if (int64 > _I32_MAX || int64 < _I32_MIN) {
           throw Exception.Overflow
         }
         WasmI32.wrapI64(int64)
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        BI.toInt32(x)
+        BI.toInt32(xVal)
       },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
@@ -512,31 +518,33 @@ provide let coerceNumberToWasmI32 = (x: Number) => {
       },
     }
   }
+  ignore(x)
+  result
 }
 
 @unsafe
 provide let coerceNumberToUnsignedWasmI64 = (x: Number) => {
   use WasmI32.{ (<) }
-  let x = WasmI32.fromGrain(x)
-  if (isSimpleNumber(x)) {
-    let num = untagSimple(x)
+  let xVal = WasmI32.fromGrain(x)
+  let result = if (isSimpleNumber(xVal)) {
+    let num = untagSimple(xVal)
     if (num < 0n) {
       throw Exception.Overflow
     }
     WasmI64.extendI32U(num)
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
         use WasmI64.{ (<) }
-        let int64 = boxedInt64Number(x)
+        let int64 = boxedInt64Number(xVal)
         if (int64 < 0N) {
           throw Exception.Overflow
         }
         int64
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        BI.toUnsignedInt64(x)
+        BI.toUnsignedInt64(xVal)
       },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
@@ -544,31 +552,33 @@ provide let coerceNumberToUnsignedWasmI64 = (x: Number) => {
       },
     }
   }
+  ignore(x)
+  result
 }
 
 @unsafe
 provide let coerceNumberToUnsignedWasmI32 = (x: Number) => {
   use WasmI32.{ (<) }
-  let x = WasmI32.fromGrain(x)
-  if (isSimpleNumber(x)) {
-    let num = untagSimple(x)
+  let xVal = WasmI32.fromGrain(x)
+  let result = if (isSimpleNumber(xVal)) {
+    let num = untagSimple(xVal)
     if (num < 0n) {
       throw Exception.Overflow
     }
     num
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
         use WasmI64.{ (<), (>) }
-        let int64 = boxedInt64Number(x)
+        let int64 = boxedInt64Number(xVal)
         if (int64 > _U32_MAX || int64 < _U32_MIN) {
           throw Exception.Overflow
         }
         WasmI32.wrapI64(int64)
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        BI.toInt32(x)
+        BI.toInt32(xVal)
       },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
@@ -576,22 +586,24 @@ provide let coerceNumberToUnsignedWasmI32 = (x: Number) => {
       },
     }
   }
+  ignore(x)
+  result
 }
 
 @unsafe
 let coerceNumberToBigInt = (x: Number) => {
-  let x = WasmI32.fromGrain(x)
-  if (isSimpleNumber(x)) {
-    BI.makeWrappedInt32(untagSimple(x))
+  let xVal = WasmI32.fromGrain(x)
+  let result = if (isSimpleNumber(xVal)) {
+    BI.makeWrappedInt32(untagSimple(xVal))
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
-        BI.makeWrappedInt64(boxedInt64Number(x))
+        BI.makeWrappedInt64(boxedInt64Number(xVal))
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        Memory.incRef(x)
-        x
+        Memory.incRef(xVal)
+        xVal
       },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
@@ -599,6 +611,8 @@ let coerceNumberToBigInt = (x: Number) => {
       },
     }
   }
+  ignore(x)
+  result
 }
 
 @unsafe
@@ -1165,8 +1179,9 @@ provide let cmpRationals = (x, y) => {
  */
 @unsafe
 provide let rationalNumerator = (x: Rational) => {
-  let x = WasmI32.fromGrain(x)
-  let num = boxedRationalNumerator(x)
+  let xVal = WasmI32.fromGrain(x)
+  let num = boxedRationalNumerator(xVal)
+  ignore(x)
   Memory.incRef(num)
   WasmI32.toGrain(reducedBigInteger(num)): Number
 }
@@ -1181,8 +1196,9 @@ provide let rationalNumerator = (x: Rational) => {
  */
 @unsafe
 provide let rationalDenominator = (x: Rational) => {
-  let x = WasmI32.fromGrain(x)
-  let num = boxedRationalDenominator(x)
+  let xVal = WasmI32.fromGrain(x)
+  let num = boxedRationalDenominator(xVal)
+  ignore(x)
   Memory.incRef(num)
   WasmI32.toGrain(reducedBigInteger(num)): Number
 }
@@ -1912,7 +1928,10 @@ provide let (<) = (num1: Number, num2: Number) => {
   use WasmI32.{ (<) }
   let x = WasmI32.fromGrain(num1)
   let y = WasmI32.fromGrain(num2)
-  !isNaN(x) && !isNaN(y) && cmp(x, y) < 0n
+  let result = !isNaN(x) && !isNaN(y) && cmp(x, y) < 0n
+  ignore(num1)
+  ignore(num2)
+  result
 }
 
 /**
@@ -1929,7 +1948,10 @@ provide let (>) = (num1: Number, num2: Number) => {
   use WasmI32.{ (>) }
   let x = WasmI32.fromGrain(num1)
   let y = WasmI32.fromGrain(num2)
-  !isNaN(x) && !isNaN(y) && cmp(x, y) > 0n
+  let result = !isNaN(x) && !isNaN(y) && cmp(x, y) > 0n
+  ignore(num1)
+  ignore(num2)
+  result
 }
 
 /**
@@ -1946,7 +1968,10 @@ provide let (<=) = (num1: Number, num2: Number) => {
   use WasmI32.{ (<=) }
   let x = WasmI32.fromGrain(num1)
   let y = WasmI32.fromGrain(num2)
-  !isNaN(x) && !isNaN(y) && cmp(x, y) <= 0n
+  let result = !isNaN(x) && !isNaN(y) && cmp(x, y) <= 0n
+  ignore(num1)
+  ignore(num2)
+  result
 }
 
 /**
@@ -1963,14 +1988,20 @@ provide let (>=) = (num1: Number, num2: Number) => {
   use WasmI32.{ (>=) }
   let x = WasmI32.fromGrain(num1)
   let y = WasmI32.fromGrain(num2)
-  !isNaN(x) && !isNaN(y) && cmp(x, y) >= 0n
+  let result = !isNaN(x) && !isNaN(y) && cmp(x, y) >= 0n
+  ignore(num1)
+  ignore(num2)
+  result
 }
 
 @unsafe
 provide let compare = (x: Number, y: Number) => {
-  let x = WasmI32.fromGrain(x)
-  let y = WasmI32.fromGrain(y)
-  WasmI32.toGrain(tagSimple(cmp(x, y))): Number
+  let xVal = WasmI32.fromGrain(x)
+  let yVal = WasmI32.fromGrain(y)
+  let result = WasmI32.toGrain(tagSimple(cmp(xVal, yVal))): Number
+  ignore(x)
+  ignore(y)
+  result
 }
 
 /*
@@ -1979,9 +2010,12 @@ provide let compare = (x: Number, y: Number) => {
 
 @unsafe
 provide let numberEq = (x: Number, y: Number) => {
-  let x = WasmI32.fromGrain(x)
-  let y = WasmI32.fromGrain(y)
-  numberEqual(x, y)
+  let xVal = WasmI32.fromGrain(x)
+  let yVal = WasmI32.fromGrain(y)
+  let result = numberEqual(xVal, yVal)
+  ignore(x)
+  ignore(y)
+  result
 }
 
 /*
@@ -2001,12 +2035,14 @@ provide let numberEq = (x: Number, y: Number) => {
 @unsafe
 provide let lnot = (value: Number) => {
   let xw32 = WasmI32.fromGrain(value)
-  if (isBigInt(xw32)) {
+  let result = if (isBigInt(xw32)) {
     WasmI32.toGrain(reducedBigInteger(BI.bitwiseNot(xw32))): Number
   } else {
     let xval = coerceNumberToWasmI64(value)
     WasmI32.toGrain(reducedInteger(i64not(xval))): Number
   }
+  ignore(value)
+  result
 }
 
 /**
@@ -2024,7 +2060,7 @@ provide let lnot = (value: Number) => {
 provide let (<<) = (value: Number, amount: Number) => {
   use WasmI64.{ (-), (<<) }
   let xw32 = WasmI32.fromGrain(value)
-  if (isBigInt(xw32)) {
+  let result = if (isBigInt(xw32)) {
     let yval = coerceNumberToWasmI32(amount)
     WasmI32.toGrain(reducedBigInteger(BI.shl(xw32, yval))): Number
   } else {
@@ -2040,6 +2076,8 @@ provide let (<<) = (value: Number, amount: Number) => {
       WasmI32.toGrain(reducedInteger(xval << yval)): Number
     }
   }
+  ignore(value)
+  result
 }
 
 /**
@@ -2057,7 +2095,7 @@ provide let (<<) = (value: Number, amount: Number) => {
 provide let (>>>) = (value: Number, amount: Number) => {
   use WasmI64.{ (>>>) }
   let xw32 = WasmI32.fromGrain(value)
-  if (isBigInt(xw32)) {
+  let result = if (isBigInt(xw32)) {
     let yval = coerceNumberToWasmI32(amount)
     // [NOTE]: For BigInts, shrU is the same as shrS because there
     //         are an *infinite* number of leading ones
@@ -2067,6 +2105,8 @@ provide let (>>>) = (value: Number, amount: Number) => {
     let yval = coerceNumberToWasmI64(amount)
     WasmI32.toGrain(reducedInteger(xval >>> yval)): Number
   }
+  ignore(value)
+  result
 }
 
 /**
@@ -2085,7 +2125,7 @@ provide let (&) = (value1: Number, value2: Number) => {
   use WasmI64.{ (&) }
   let xw32 = WasmI32.fromGrain(value1)
   let yw32 = WasmI32.fromGrain(value2)
-  if (isBigInt(xw32) || isBigInt(yw32)) {
+  let result = if (isBigInt(xw32) || isBigInt(yw32)) {
     let xval = coerceNumberToBigInt(value1)
     let yval = coerceNumberToBigInt(value2)
     let ret = WasmI32.toGrain(reducedBigInteger(BI.bitwiseAnd(xval, yval))):
@@ -2104,6 +2144,9 @@ provide let (&) = (value1: Number, value2: Number) => {
     let yval = coerceNumberToWasmI64(value2)
     WasmI32.toGrain(reducedInteger(xval & yval)): Number
   }
+  ignore(value1)
+  ignore(value2)
+  result
 }
 
 /**
@@ -2122,7 +2165,7 @@ provide let (|) = (value1: Number, value2: Number) => {
   use WasmI64.{ (|) }
   let xw32 = WasmI32.fromGrain(value1)
   let yw32 = WasmI32.fromGrain(value2)
-  if (isBigInt(xw32) || isBigInt(yw32)) {
+  let result = if (isBigInt(xw32) || isBigInt(yw32)) {
     let xval = coerceNumberToBigInt(value1)
     let yval = coerceNumberToBigInt(value2)
     let ret = WasmI32.toGrain(reducedBigInteger(BI.bitwiseOr(xval, yval))):
@@ -2141,6 +2184,9 @@ provide let (|) = (value1: Number, value2: Number) => {
     let yval = coerceNumberToWasmI64(value2)
     WasmI32.toGrain(reducedInteger(xval | yval)): Number
   }
+  ignore(value1)
+  ignore(value2)
+  result
 }
 
 /**
@@ -2160,7 +2206,7 @@ provide let (^) = (value1: Number, value2: Number) => {
   use WasmI64.{ (^) }
   let xw32 = WasmI32.fromGrain(value1)
   let yw32 = WasmI32.fromGrain(value2)
-  if (isBigInt(xw32) || isBigInt(yw32)) {
+  let result = if (isBigInt(xw32) || isBigInt(yw32)) {
     let xval = coerceNumberToBigInt(value1)
     let yval = coerceNumberToBigInt(value2)
     let ret = WasmI32.toGrain(reducedBigInteger(BI.bitwiseXor(xval, yval))):
@@ -2179,6 +2225,9 @@ provide let (^) = (value1: Number, value2: Number) => {
     let yval = coerceNumberToWasmI64(value2)
     WasmI32.toGrain(reducedInteger(xval ^ yval)): Number
   }
+  ignore(value1)
+  ignore(value2)
+  result
 }
 
 /**
@@ -2196,7 +2245,7 @@ provide let (^) = (value1: Number, value2: Number) => {
 provide let (>>) = (value: Number, amount: Number) => {
   use WasmI64.{ (>>) }
   let xw32 = WasmI32.fromGrain(value)
-  if (isBigInt(xw32)) {
+  let result = if (isBigInt(xw32)) {
     let yval = coerceNumberToWasmI32(amount)
     // [NOTE]: For BigInts, shrU is the same as shrS because there
     //         are an *infinite* number of leading ones
@@ -2206,6 +2255,8 @@ provide let (>>) = (value: Number, amount: Number) => {
     let yval = coerceNumberToWasmI64(amount)
     WasmI32.toGrain(reducedInteger(xval >> yval)): Number
   }
+  ignore(value)
+  result
 }
 
 /// USER-EXPOSED COERCION FUNCTIONS
@@ -2216,22 +2267,22 @@ provide let (>>) = (value: Number, amount: Number) => {
 @unsafe
 let coerceNumberToShortUint = (x: Number, max32, max64, is8bit) => {
   use WasmI32.{ (&), (<), (>) }
-  let x = WasmI32.fromGrain(x)
-  let int32 = if (isSimpleNumber(x)) {
-    untagSimple(x)
+  let xVal = WasmI32.fromGrain(x)
+  let int32 = if (isSimpleNumber(xVal)) {
+    untagSimple(xVal)
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
         use WasmI64.{ (<), (>) }
-        let int64 = boxedInt64Number(x)
+        let int64 = boxedInt64Number(xVal)
         if (int64 > max64 || int64 < 0N) {
           throw Exception.Overflow
         }
         WasmI32.wrapI64(int64)
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        BI.toInt32(x)
+        BI.toInt32(xVal)
       },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
@@ -2239,6 +2290,7 @@ let coerceNumberToShortUint = (x: Number, max32, max64, is8bit) => {
       },
     }
   }
+  ignore(x)
   if (int32 > max32 || int32 < 0n) {
     throw Exception.Overflow
   }
@@ -2248,22 +2300,22 @@ let coerceNumberToShortUint = (x: Number, max32, max64, is8bit) => {
 @unsafe
 let coerceNumberToShortInt = (x: Number, min32, max32, min64, max64, is8bit) => {
   use WasmI32.{ (<), (>) }
-  let x = WasmI32.fromGrain(x)
-  let int32 = if (isSimpleNumber(x)) {
-    untagSimple(x)
+  let xVal = WasmI32.fromGrain(x)
+  let int32 = if (isSimpleNumber(xVal)) {
+    untagSimple(xVal)
   } else {
-    let xtag = boxedNumberTag(x)
+    let xtag = boxedNumberTag(xVal)
     match (xtag) {
       t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
         use WasmI64.{ (<), (>) }
-        let int64 = boxedInt64Number(x)
+        let int64 = boxedInt64Number(xVal)
         if (int64 > max64 || int64 < min64) {
           throw Exception.Overflow
         }
         WasmI32.wrapI64(int64)
       },
       t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
-        BI.toInt32(x)
+        BI.toInt32(xVal)
       },
       _ => {
         // rationals are never integral, and we refuse to coerce floats to ints
@@ -2271,6 +2323,7 @@ let coerceNumberToShortInt = (x: Number, min32, max32, min64, max64, is8bit) =>
       },
     }
   }
+  ignore(x)
   if (int32 > max32 || int32 < min32) {
     throw Exception.Overflow
   }
@@ -2384,6 +2437,7 @@ provide let coerceNumberToInt64 = (number: Number) => {
     Memory.incRef(x)
     newInt64(coerceNumberToWasmI64(WasmI32.toGrain(x): Number))
   }
+  ignore(number)
   WasmI32.toGrain(result): Int64
 }
 
@@ -2430,6 +2484,7 @@ provide let coerceNumberToRational = (number: Number) => {
       throw Exception.NumberNotRational
     }
   }
+  ignore(number)
   WasmI32.toGrain(result): Rational
 }
 
@@ -2470,6 +2525,7 @@ provide let coerceNumberToFloat64 = (number: Number) => {
     Memory.incRef(x)
     newFloat64(coerceNumberToWasmF64(WasmI32.toGrain(x): Number))
   }
+  ignore(number)
   WasmI32.toGrain(result): Float64
 }
 
@@ -2541,6 +2597,7 @@ provide let coerceUint16ToNumber = (value: Uint16) => {
 provide let coerceInt32ToNumber = (value: Int32) => {
   let x = WasmI32.load(WasmI32.fromGrain(value), 4n)
   let result = reducedInteger(WasmI64.extendI32S(x))
+  ignore(value)
   WasmI32.toGrain(result): Number
 }
 
@@ -2554,8 +2611,10 @@ provide let coerceInt32ToNumber = (value: Int32) => {
  */
 @unsafe
 provide let coerceInt64ToNumber = (value: Int64) => {
-  WasmI32.toGrain(reducedInteger(boxedInt64Number(WasmI32.fromGrain(value)))):
-    Number
+  let x = WasmI32.fromGrain(value)
+  let result = WasmI32.toGrain(reducedInteger(boxedInt64Number(x))): Number
+  ignore(value)
+  result
 }
 
 /**
@@ -2572,7 +2631,9 @@ provide let coerceBigIntToNumber = (num: BigInt) => {
   // reducedBigInteger assumes that the bigint is dead,
   // but in our case, it is not
   Memory.incRef(x)
-  WasmI32.toGrain(reducedBigInteger(x)): Number
+  let result = WasmI32.toGrain(reducedBigInteger(x)): Number
+  ignore(num)
+  result
 }
 
 /**
@@ -2594,7 +2655,9 @@ provide let coerceRationalToNumber = (rational: Rational) => {
   }
   // incRef x to reuse it via WasmI32.toGrain
   Memory.incRef(x)
-  WasmI32.toGrain(x): Number
+  let result = WasmI32.toGrain(x): Number
+  ignore(rational)
+  result
 }
 
 /**
@@ -2609,7 +2672,9 @@ provide let coerceRationalToNumber = (rational: Rational) => {
 provide let coerceFloat32ToNumber = (float: Float32) => {
   let x = WasmF32.load(WasmI32.fromGrain(float), 4n)
   let x64 = WasmF64.promoteF32(x)
-  WasmI32.toGrain(newFloat64(x64)): Number
+  let result = WasmI32.toGrain(newFloat64(x64)): Number
+  ignore(float)
+  result
 }
 
 /**
@@ -2625,7 +2690,9 @@ provide let coerceFloat64ToNumber = (float: Float64) => {
   let x = WasmI32.fromGrain(float)
   // incRef x to reuse it via WasmI32.toGrain
   Memory.incRef(x)
-  WasmI32.toGrain(x): Number
+  let result = WasmI32.toGrain(x): Number
+  ignore(float)
+  result
 }
 
 /// USER-EXPOSED CONVERSION FUNCTIONS
@@ -2666,7 +2733,10 @@ let convertInexactToExactHelp = x => {
 
 @unsafe
 provide let convertInexactToExact = (x: Number) => {
-  WasmI32.toGrain(convertInexactToExactHelp(WasmI32.fromGrain(x))): Number
+  let xVal = WasmI32.fromGrain(x)
+  let result = WasmI32.toGrain(convertInexactToExactHelp(xVal)): Number
+  ignore(x)
+  result
 }
 
 /**
@@ -2751,7 +2821,10 @@ provide let (/) = (num1: Number, num2: Number) => {
 provide let (%) = (num1: Number, num2: Number) => {
   let x = WasmI32.fromGrain(num1)
   let y = WasmI32.fromGrain(num2)
-  WasmI32.toGrain(numberMod(x, y)): Number
+  let result = WasmI32.toGrain(numberMod(x, y)): Number
+  ignore(num1)
+  ignore(num2)
+  result
 }
 
 // inc/dec
@@ -2782,8 +2855,10 @@ provide let decr = value => {
 
 @unsafe
 provide let isBigInt = x => {
-  let x = WasmI32.fromGrain(x)
-  isBigInt(x)
+  let xVal = WasmI32.fromGrain(x)
+  let result = isBigInt(xVal)
+  ignore(x)
+  result
 }
 
 // Scalbn is based on https://git.musl-libc.org/cgit/musl/tree/src/math/scalbn.c
@@ -2874,13 +2949,13 @@ provide let (**) = (base, power) => {
   let (!=) = (x, y) => !numberEq(x, y)
   let basePtr = WasmI32.fromGrain(base)
   let powerPtr = WasmI32.fromGrain(power)
-  if (base == 1 && power != 0) {
-    return 1
+  let result = if (base == 1 && power != 0) {
+    1
   } else if (isInteger(basePtr) && isInteger(powerPtr)) {
     if (power < 0)
-      return expBySquaring(1, 1 / base, power * -1)
+      expBySquaring(1, 1 / base, power * -1)
     else
-      return expBySquaring(1, base, power)
+      expBySquaring(1, base, power)
   } else if (isRational(basePtr) && isInteger(powerPtr)) {
     // Apply expBySquaring to numerator and denominator
     let numerator = WasmI32.fromGrain(base)
@@ -2899,7 +2974,7 @@ provide let (**) = (base, power) => {
       expBySquaring(1, 1 / denominator, power * -1)
     else
       expBySquaring(1, denominator, power)
-    return numerator / denominator
+    numerator / denominator
   } else {
     // Based on https://git.musl-libc.org/cgit/musl/tree/src/math/pow.c
     use WasmF64.{ (==), (!=), (<=), (/), (*), (+) }
@@ -3248,6 +3323,12 @@ provide let (**) = (base, power) => {
         WasmI64.reinterpretF64(z) & 0xFFFFFFFFN | WasmI64.extendI32S(j) << 32N
       )
     }
-    return WasmI32.toGrain(newFloat64(s * z)): Number
+    WasmI32.toGrain(newFloat64(s * z)): Number
   }
+
+  ignore(base)
+  ignore(power)
+
+  // This return is never hit but is here because we need to hold on to references
+  return result
 }