fix(stdlib): Ensure references are retained in unsafe stdlib functions

stdlib/array.gr

@@ -91,6 +91,7 @@ provide let make = (length: Number, item: a) => {
  _ARRAY_START_OFFSET
  )
  }
+ ignore(item)
  WasmI32.toGrain(array): Array<a>
 }
 
@@ -988,6 +989,7 @@ provide let join = (separator: String, items: Array<String>) => {
  if (i != arrLen) Memory.copy(offset, sepPtr, sepSize)
  offset += sepSize
  }
+ ignore(separator)
  WasmI32.toGrain(newString): String
 }
 

stdlib/bytes.gr

@@ -113,6 +113,7 @@ provide let fromString = (string: String) => {
  let size = getSize(src)
  let dst = allocateBytes(size)
  Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+ ignore(string)
  WasmI32.toGrain(dst): Bytes
 }
 
@@ -134,6 +135,7 @@ provide let toString = (bytes: Bytes) => {
  let size = getSize(src)
  let dst = allocateString(size)
  Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+ ignore(bytes)
  WasmI32.toGrain(dst): String
 }
 
@@ -151,7 +153,9 @@ provide let toString = (bytes: Bytes) => {
 @unsafe
 provide let length = (bytes: Bytes) => {
  let b = WasmI32.fromGrain(bytes)
- Conv.wasmI32ToNumber(getSize(b))
+ let result = Conv.wasmI32ToNumber(getSize(b))
+ ignore(bytes)
+ result
 }
 
 /**
@@ -171,6 +175,7 @@ provide let copy = (bytes: Bytes) => {
  let size = getSize(src)
  let dst = allocateBytes(size)
  Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+ ignore(bytes)
  WasmI32.toGrain(dst): Bytes
 }
 
@@ -208,6 +213,7 @@ provide let slice = (start: Number, length: Number, bytes: Bytes) => {
  let dst = allocateBytes(length)
  let offset = start
  Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET + start, length)
+ ignore(bytes)
  WasmI32.toGrain(dst): Bytes
 }
 
@@ -263,6 +269,7 @@ provide let resize = (left: Number, right: Number, bytes: Bytes) => {
  len
  )
  }
+ ignore(bytes)
  WasmI32.toGrain(dst): Bytes
 }
 
@@ -298,11 +305,11 @@ provide let move = (
  let srcIndexOrig = srcIndex
  let dstIndexOrig = dstIndex
  let lenthOrig = length
- let src = WasmI32.fromGrain(src)
- let srcSize = getSize(src)
+ let srcPtr = WasmI32.fromGrain(src)
+ let srcSize = getSize(srcPtr)
  let srcIndex = coerceNumberToWasmI32(srcIndex)
- let dst = WasmI32.fromGrain(dst)
- let dstSize = getSize(dst)
+ let dstPtr = WasmI32.fromGrain(dst)
+ let dstSize = getSize(dstPtr)
  let dstIndex = coerceNumberToWasmI32(dstIndex)
  let length = coerceNumberToWasmI32(length)
  if (srcIndex + length > srcSize) {
@@ -313,10 +320,12 @@ provide let move = (
  }
  let end = srcIndex + length
  Memory.copy(
- dst + _VALUE_OFFSET + dstIndex,
- src + _VALUE_OFFSET + srcIndex,
+ dstPtr + _VALUE_OFFSET + dstIndex,
+ srcPtr + _VALUE_OFFSET + srcIndex,
  length
  )
+ ignore(src)
+ ignore(dst)
 }
 
 /**
@@ -362,6 +371,7 @@ provide let fill = (value: Uint8, bytes: Bytes) => {
  let size = getSize(src)
  let v = untagUint8(value)
  Memory.fill(src + _VALUE_OFFSET, v, size)
+ ignore(bytes)
 }
 
 /**
@@ -383,6 +393,7 @@ provide let clear = (bytes: Bytes) => {
  let src = WasmI32.fromGrain(bytes)
  let size = getSize(src)
  Memory.fill(src + _VALUE_OFFSET, 0n, size)
+ ignore(bytes)
 }
 
 /**
@@ -411,6 +422,7 @@ provide let getInt8 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
  let n = WasmI32.load8S(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  tagInt8(n)
 }
 
@@ -440,6 +452,7 @@ provide let setInt8 = (index: Number, value: Int8, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
  let v = untagInt8(value)
+ ignore(bytes)
  WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
 }
 
@@ -469,6 +482,7 @@ provide let getUint8 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
  let n = WasmI32.load8U(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  tagUint8(n)
 }
 
@@ -498,6 +512,7 @@ provide let setUint8 = (index: Number, value: Uint8, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
  let v = untagUint8(value)
  WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }
 
 /**
@@ -526,6 +541,7 @@ provide let getInt16 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
  let n = WasmI32.load16S(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  tagInt16(n)
 }
 
@@ -556,6 +572,7 @@ provide let setInt16 = (index: Number, value: Int16, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
  let v = untagInt16(value)
  WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }
 
 /**
@@ -584,6 +601,7 @@ provide let getUint16 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
  let n = WasmI32.load16U(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  tagUint16(n)
 }
 
@@ -613,6 +631,7 @@ provide let setUint16 = (index: Number, value: Uint16, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
  let v = untagUint16(value)
  WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }
 
 /**
@@ -640,6 +659,7 @@ provide let getInt32 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
  let n = WasmI32.load(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  Conv.toInt32(n)
 }
 
@@ -669,6 +689,7 @@ provide let setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
  let v = Conv.fromInt32(value)
  WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }
 
 /**
@@ -696,6 +717,7 @@ provide let getUint32 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
  let n = WasmI32.load(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  Conv.toUint32(n)
 }
 
@@ -725,6 +747,7 @@ provide let setUint32 = (index: Number, value: Uint32, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
  let v = Conv.fromUint32(value)
  WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }
 
 /**
@@ -752,6 +775,7 @@ provide let getFloat32 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
  let n = WasmF32.load(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  Conv.toFloat32(n)
 }
 
@@ -781,6 +805,7 @@ provide let setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
  let v = Conv.fromFloat32(value)
  WasmF32.store(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }
 
 /**
@@ -808,6 +833,7 @@ provide let getInt64 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
  let n = WasmI64.load(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  Conv.toInt64(n)
 }
 
@@ -837,6 +863,7 @@ provide let setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
  let v = Conv.fromInt64(value)
  WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }
 
 /**
@@ -864,6 +891,7 @@ provide let getUint64 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
  let n = WasmI64.load(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  Conv.toUint64(n)
 }
 
@@ -893,6 +921,7 @@ provide let setUint64 = (index: Number, value: Uint64, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
  let v = Conv.fromUint64(value)
  WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }
 
 /**
@@ -920,6 +949,7 @@ provide let getFloat64 = (index: Number, bytes: Bytes) => {
  let offset = coerceNumberToWasmI32(index)
  checkIndexIsInBounds(offset, _FLOAT64_BYTE_SIZE, size)
  let n = WasmF64.load(ptr + offset, _VALUE_OFFSET)
+ ignore(bytes)
  Conv.toFloat64(n)
 }
 
@@ -949,4 +979,5 @@ provide let setFloat64 = (index: Number, value: Float64, bytes: Bytes) => {
  checkIndexIsInBounds(offset, _FLOAT64_BYTE_SIZE, size)
  let v = Conv.fromFloat64(value)
  WasmF64.store(ptr + offset, v, _VALUE_OFFSET)
+ ignore(bytes)
 }

stdlib/hash.gr

@@ -262,6 +262,8 @@ provide let hash = anything => {
  }
 
  hashOne(WasmI32.fromGrain(anything), 0n)
+ ignore(anything)
+
  finalize(0n)
 
  // Tag the number on the way out.

stdlib/map.gr

@@ -436,13 +436,14 @@ provide let toArray = (map: Map<a, b>) => {
  use WasmI32.{ (+) as addWasmI32 }
  // Assign the values into the array.
  // We store them directly to prevent GC on uninitialized array data.
- let array = WasmI32.fromGrain(array)
+ let arrayPtr = WasmI32.fromGrain(array)
  let item = (key, value)
  WasmI32.store(
- addWasmI32(array, untagSimpleNumber(i) * 4n),
+ addWasmI32(arrayPtr, untagSimpleNumber(i) * 4n),
  Memory.incRef(WasmI32.fromGrain(item)),
  8n
  )
+ ignore(array)
  i + 1
  }
  reduce(reducer, 0, map)