goscript 0.1.0 → 0.1.1

package/gs/builtin/builtin.ts

@@ -35,7 +35,7 @@ export function panic(...args: any[]): never {
  * For maps, it deletes all entries.
  * @param v The slice or map to clear
  */
-export function clear<T>(v: T[] | Map<unknown, unknown> | null): void {
+export function clear<T>(v: Slice<T> | Map<unknown, unknown> | null): void {
   if (v === null || v === undefined) {
     return
   }
@@ -43,12 +43,40 @@ export function clear<T>(v: T[] | Map<unknown, unknown> | null): void {
     v.clear()
     return
   }
+  if (v instanceof Uint8Array) {
+    v.fill(0)
+    return
+  }
+  if (isSliceProxy(v)) {
+    const zero = clearZeroValue(v)
+    for (let i = 0; i < v.length; i++) {
+      v[i] = zero
+    }
+    return
+  }
   if (Array.isArray(v)) {
-    v.fill(null as T)
+    v.fill(clearZeroValue(v))
     return
   }
 }
 
+function clearZeroValue<T>(v: T[]): T {
+  for (const item of v) {
+    if (item !== null && item !== undefined) {
+      switch (typeof item) {
+        case 'number':
+          return 0 as T
+        case 'string':
+          return '' as T
+        case 'boolean':
+          return false as T
+      }
+      break
+    }
+  }
+  return null as T
+}
+
 /**
  * assignStruct copies all field values from source struct to target struct.
  * Used for pointer dereference assignment: *p = value
@@ -96,13 +124,137 @@ export function pointerValue<T>(value: T | VarRef<T> | null | undefined): T {
   return value
 }
 
+export function arrayEqual(a: unknown, b: unknown): boolean {
+  return comparableEqual(a, b)
+}
+
+function comparableEqual(a: unknown, b: unknown): boolean {
+  if (a === b) {
+    return true
+  }
+  if (a === null || a === undefined || b === null || b === undefined) {
+    return false
+  }
+  if (isArrayLike(a) && isArrayLike(b)) {
+    if (a.length !== b.length) {
+      return false
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!comparableEqual(a[i], b[i])) {
+        return false
+      }
+    }
+    return true
+  }
+  if (hasGoType(a) || hasGoType(b)) {
+    if (!hasGoType(a) || !hasGoType(b) || a.__goType !== b.__goType) {
+      return false
+    }
+    if (a.__isTypedNil || b.__isTypedNil) {
+      return a.__isTypedNil === true && b.__isTypedNil === true
+    }
+  }
+  if (isStructValue(a) && isStructValue(b)) {
+    return fieldsEqual(a._fields, b._fields)
+  }
+  return false
+}
+
+function isArrayLike(value: unknown): value is ArrayLike<unknown> {
+  return Array.isArray(value) || value instanceof Uint8Array
+}
+
+function hasGoType(value: unknown): value is {
+  __goType: string
+  __isTypedNil?: boolean
+} {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { __goType?: unknown }).__goType === 'string'
+  )
+}
+
+function isStructValue(value: unknown): value is {
+  _fields: Record<string, VarRef<unknown>>
+} {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { _fields?: unknown })._fields === 'object' &&
+    (value as { _fields?: unknown })._fields !== null
+  )
+}
+
+function fieldsEqual(
+  a: Record<string, VarRef<unknown>>,
+  b: Record<string, VarRef<unknown>>,
+): boolean {
+  const aKeys = Object.keys(a)
+  const bKeys = Object.keys(b)
+  if (aKeys.length !== bKeys.length) {
+    return false
+  }
+  for (const key of aKeys) {
+    if (!(key in b) || !comparableEqual(a[key].value, b[key].value)) {
+      return false
+    }
+  }
+  return true
+}
+
+export interface Complex {
+  real: number
+  imag: number
+}
+
+export function complex(real: number, imag: number): Complex {
+  return { real, imag }
+}
+
+export function real(value: number | Complex | null | undefined): number {
+  if (typeof value === 'number') {
+    return value
+  }
+  return value?.real ?? 0
+}
+
+export function imag(value: number | Complex | null | undefined): number {
+  if (typeof value === 'number') {
+    return 0
+  }
+  return value?.imag ?? 0
+}
+
 // Bytes represents all valid []byte representations in TypeScript
 // This includes Uint8Array (the preferred representation) and $.Slice<number> (which includes null)
 export type Bytes = Uint8Array | Slice<number>
 
 // int converts a value to a Go int type, handling proper signed integer conversion
 // This ensures that values like 2147483648 (2^31) are properly handled according to Go semantics
-export function int(value: number): number {
+export function int(value: number | bigint, bits = 0): number {
+  if (typeof value === 'bigint') {
+    if (bits > 0 && bits <= 64) {
+      return Number(BigInt.asIntN(bits, value))
+    }
+    return Number(value)
+  }
+  if (bits > 0 && bits < 64) {
+    const modulo = 2 ** bits
+    const sign = 2 ** (bits - 1)
+    let truncated = Math.trunc(value)
+    if (!Number.isFinite(truncated)) {
+      return truncated
+    }
+    truncated %= modulo
+    if (truncated < 0) {
+      truncated += modulo
+    }
+    if (truncated >= sign) {
+      truncated -= modulo
+    }
+    return truncated
+  }
   // In Go, int is typically 64-bit on 64-bit systems, but for compatibility with JavaScript
   // we need to handle the conversion properly. The issue is that JavaScript's number type
   // can represent values larger than 32-bit signed integers, but when cast in certain contexts
@@ -115,6 +267,86 @@ export function int(value: number): number {
   return Math.trunc(value)
 }
 
+// uint converts a value to an unsigned Go integer width.
+export function uint(value: number | bigint, bits = 64): number {
+  if (typeof value === 'bigint') {
+    const normalized = BigInt.asUintN(Math.min(bits, 64), value)
+    if (bits >= 64) {
+      return normalized as unknown as number
+    }
+    return Number(normalized)
+  }
+  const modulo = bits >= 64 ? 2 ** 64 : 2 ** bits
+  let truncated = Math.trunc(value)
+  if (!Number.isFinite(truncated)) {
+    return truncated
+  }
+  truncated %= modulo
+  if (truncated < 0) {
+    truncated += modulo
+  }
+  return truncated
+}
+
+export function uint64Shl(value: number | bigint, shift: number | bigint): number {
+  return uint64Result(uint64Value(value) << BigInt(Math.trunc(Number(shift))))
+}
+
+export function uint64Shr(value: number | bigint, shift: number | bigint): number {
+  return uint64Result(uint64Value(value) >> BigInt(Math.trunc(Number(shift))))
+}
+
+export function uintShr(
+  value: number | bigint,
+  shift: number | bigint,
+  bits = 32,
+): number {
+  const width = Math.min(bits, 32)
+  const amount = Math.trunc(Number(shift))
+  if (amount < 0) {
+    throw new Error('runtime error: negative shift amount')
+  }
+  if (amount >= width) {
+    return 0
+  }
+  return uint(value, width) >>> amount
+}
+
+export function uint64Mul(left: number | bigint, right: number | bigint): number {
+  return uint64Result(uint64Value(left) * uint64Value(right))
+}
+
+export function uint64Add(left: number | bigint, right: number | bigint): number {
+  return uint64Result(uint64Value(left) + uint64Value(right))
+}
+
+export function uint64Sub(left: number | bigint, right: number | bigint): number {
+  return uint64Result(uint64Value(left) - uint64Value(right))
+}
+
+export function uint64And(left: number | bigint, right: number | bigint): number {
+  return uint64Result(uint64Value(left) & uint64Value(right))
+}
+
+export function uint64Or(left: number | bigint, right: number | bigint): number {
+  return uint64Result(uint64Value(left) | uint64Value(right))
+}
+
+export function uint64Xor(left: number | bigint, right: number | bigint): number {
+  return uint64Result(uint64Value(left) ^ uint64Value(right))
+}
+
+function uint64Value(value: number | bigint): bigint {
+  if (typeof value === 'bigint') {
+    return BigInt.asUintN(64, value)
+  }
+  return BigInt.asUintN(64, BigInt(Math.trunc(value)))
+}
+
+function uint64Result(value: bigint): number {
+  return BigInt.asUintN(64, value) as unknown as number
+}
+
 /**
  * Normalizes various byte representations into a `Uint8Array` for protobuf compatibility.
  *
@@ -248,17 +480,16 @@ export function bytesToArray(bytes: Bytes | null): number[] {
     return Array.from(bytes)
   }
 
-  if (Array.isArray(bytes)) {
-    return bytes
-  }
-
-  // Handle SliceProxy
   if (isSliceProxy(bytes)) {
     const proxy = bytes as SliceProxy<number>
     const meta = proxy.__meta__
     return meta.backing.slice(meta.offset, meta.offset + meta.length)
   }
 
+  if (Array.isArray(bytes)) {
+    return bytes
+  }
+
   throw new Error(`Cannot convert bytes of type ${typeof bytes} to array`)
 }
 

package/gs/builtin/channel.ts

@@ -77,6 +77,11 @@ export interface Channel<T> {
    * Used for non-blocking select operations.
    */
   canSendNonBlocking(): boolean
+
+  /**
+   * Reports the number of buffered values currently queued in the channel.
+   */
+  len(): number
 }
 
 /**
@@ -530,6 +535,10 @@ class BufferedChannel<T> implements Channel<T> {
       this.receiversWithOk.length > 0
     )
   }
+
+  len(): number {
+    return this.buffer.length
+  }
 }
 
 /**
@@ -555,6 +564,7 @@ export interface ChannelRef<T> {
   canReceiveNonBlocking(): boolean
   selectSend(value: T, id: number): Promise<SelectResult<boolean>>
   selectReceive(id: number): Promise<SelectResult<T>>
+  len(): number
 }
 
 /**
@@ -597,6 +607,10 @@ export class BidirectionalChannelRef<T> implements ChannelRef<T> {
   selectReceive(id: number): Promise<SelectResult<T>> {
     return this.channel.selectReceive(id)
   }
+
+  len(): number {
+    return this.channel.len()
+  }
 }
 
 /**
@@ -641,6 +655,10 @@ export class SendOnlyChannelRef<T> implements ChannelRef<T> {
   selectReceive(_id: number): Promise<SelectResult<T>> {
     throw new Error('Cannot receive from send-only channel')
   }
+
+  len(): number {
+    return this.channel.len()
+  }
 }
 
 /**
@@ -685,6 +703,10 @@ export class ReceiveOnlyChannelRef<T> implements ChannelRef<T> {
   selectSend(_value: T, _id: number): Promise<SelectResult<boolean>> {
     throw new Error('Cannot send to receive-only channel')
   }
+
+  len(): number {
+    return this.channel.len()
+  }
 }
 
 /**

package/gs/builtin/runtime-contract.test.ts

@@ -1,13 +1,21 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import {
+  bytesToUint8Array,
   byte,
+  cap,
+  cloneStructValue,
   callGenericMethod,
   chanRecvWithOk,
   functionValue,
   genericZero,
+  goSlice,
   int,
+  indexAddress,
+  indexRef,
   interfaceValue,
+  len,
+  makeSlice,
   makeChannel,
   makeMap,
   mapGet,
@@ -18,13 +26,26 @@ import {
   pointerValue,
   print,
   println,
+  rangeString,
   registerInterfaceType,
   registerStructType,
   resetHostRuntimeForTests,
+  sliceToArray,
   TypeKind,
   typeAssert,
   typedNil,
+  uint,
+  uint64Add,
+  uint64And,
+  uint64Mul,
+  uint64Or,
+  uint64Shl,
+  uint64Shr,
+  uint64Sub,
+  uint64Xor,
+  uintShr,
   unref,
+  unsupportedPointerRef,
   varRef,
 } from './index.js'
 
@@ -90,14 +111,54 @@ describe('builtin runtime contract helpers', () => {
 
   it('exposes numeric, varref, map, and error helpers', () => {
     expect(int(1.9)).toBe(1)
+    expect(int(3n)).toBe(3)
+    expect(uint(-1n, 8)).toBe(255)
     expect(byte(257)).toBe(1)
+    expect(uint(uint64Shl(1n, 63), 32)).toBe(0)
+    expect(uint(uint64Shr(uint64Shl(1n, 63), 60), 32)).toBe(8)
+    expect(uint(uint64Mul(0xffffffffffffffffn, 3), 32)).toBe(0xfffffffd)
+    expect(uint(uint64Add(0xffffffffffffffffn, 2), 32)).toBe(1)
+    expect(uint(uint64Sub(1n, 2), 32)).toBe(0xffffffff)
+    expect(uint(uint64And(0xf0n, 0x3cn), 32)).toBe(0x30)
+    expect(uint(uint64Or(0xf0n, 0x0fn), 32)).toBe(0xff)
+    expect(uint(uint64Xor(0xf0n, 0xffn), 32)).toBe(0x0f)
+    expect(uintShr(0x80000000, 31, 32)).toBe(1)
+    expect(uintShr(0x80000000, 32, 32)).toBe(0)
+    expect(uintShr(0xff, 4, 8)).toBe(15)
 
     const value = varRef(4)
     value.value = 8
     expect(unref(value)).toBe(8)
     expect(pointerValue(value)).toBe(8)
+    const pointerAssert = typeAssert<typeof value>(value, {
+      kind: TypeKind.Pointer,
+      elemType: { kind: TypeKind.Basic, name: 'int' },
+    })
+    expect(pointerAssert).toEqual({ value, ok: true })
+    const nilNamedSlice = varRef(null)
+    const nilNamedSliceIface = interfaceValue(
+      nilNamedSlice,
+      '*main.ObjectIdentifier',
+    )
+    expect(
+      typeAssert<typeof nilNamedSlice>(nilNamedSliceIface, {
+        kind: TypeKind.Pointer,
+        elemType: 'main.ObjectIdentifier',
+      }),
+    ).toEqual({ value: nilNamedSlice, ok: true })
     expect(pointerValue({ ok: true })).toEqual({ ok: true })
+    expect(cloneStructValue({ clone: () => ({ ok: true }) })).toEqual({
+      ok: true,
+    })
+    expect(
+      cloneStructValue({ __goscriptClone: () => ({ internal: true }) }),
+    ).toEqual({ internal: true })
     expect(() => pointerValue(null)).toThrow('nil pointer dereference')
+    const unsupported = unsupportedPointerRef<number>(0)
+    expect(() => unsupported.value).toThrow('unsafe pointer dereference')
+    expect(() => {
+      unsupported.value = 1
+    }).toThrow('unsafe pointer dereference')
 
     const m = makeMap<string, number>()
     mapSet(m, 'answer', 42)
@@ -105,6 +166,69 @@ describe('builtin runtime contract helpers', () => {
     expect(mapGet(m, 'missing', 0)).toEqual([0, false])
 
     expect(newError('bad')?.Error()).toBe('bad')
+    expect(rangeString('a¢€')).toEqual([
+      [0, 97],
+      [1, 162],
+      [3, 8364],
+    ])
+  })
+
+  it('exposes addressable slice and array index references', () => {
+    const values = [1, 2, 3]
+    const second = indexRef(values, 1)
+    second.value = 8
+    expect(values).toEqual([1, 8, 3])
+    expect(pointerValue(second)).toBe(8)
+
+    const view = goSlice(values, 1, 3)
+    const firstInView = indexRef(view, 0)
+    firstInView.value = 11
+    expect(values).toEqual([1, 11, 3])
+    expect(Object.getOwnPropertyDescriptor(view, '0')?.value).toBe(11)
+
+    const bytes = new Uint8Array([4, 5])
+    const firstByte = indexRef<number>(bytes, 0)
+    firstByte.value = 9
+    expect(Array.from(bytes)).toEqual([9, 5])
+
+    const byteBacking = makeSlice<number>(8, undefined, 'byte')
+    const shortBytes = goSlice(byteBacking as Uint8Array, 0, 2)
+    expect(len(shortBytes)).toBe(2)
+    expect(cap(shortBytes)).toBe(8)
+    const fullBytes = goSlice(shortBytes, 0, 8)
+    fullBytes![7] = 12
+    expect((byteBacking as Uint8Array)[7]).toBe(12)
+
+    shortBytes![0] = 14
+    expect(bytesToUint8Array(shortBytes)).toEqual(new Uint8Array([14, 0]))
+  })
+
+  it('exposes stable synthetic slice index addresses', () => {
+    const values = [1, 2, 3, 4]
+    const left = goSlice(values, 1, 3)
+    const right = goSlice(values, 2, 4)
+    const other = [8, 9]
+
+    expect(indexAddress(left, 0)).toBe(indexAddress(values, 1))
+    expect(indexAddress(left, 1)).toBe(indexAddress(right, 0))
+    expect(indexAddress(left, 1)).toBeGreaterThan(indexAddress(left, 0))
+    expect(indexAddress(other, 0)).not.toBe(indexAddress(left, 0))
+  })
+
+  it('copies slices into fixed arrays with Go length checks', () => {
+    const source = goSlice([1, 2, 3], 1, 3)
+    const array = sliceToArray<number>(source, 2)
+    array[0] = 9
+
+    expect(array).toEqual([9, 3])
+    expect(source![0]).toBe(2)
+    expect(() => sliceToArray<number>(source, 3)).toThrow(
+      'cannot convert slice with length 2 to array with length 3',
+    )
+
+    expect(sliceToArray<number>(new Uint8Array([4, 5, 6]), 2, 'byte')).toEqual(
+      new Uint8Array([4, 5]),
+    )
   })
 
   it('exposes value and type descriptor helpers', () => {
@@ -223,7 +347,9 @@ describe('builtin runtime contract helpers', () => {
   it('exposes channel helpers used by future lowering', async () => {
     const channel = makeChannel<number>(1, 0, 'both')
     await channel.send(7)
+    expect(len(channel)).toBe(1)
     expect(await chanRecvWithOk(channel)).toEqual({ value: 7, ok: true })
+    expect(len(channel)).toBe(0)
     channel.close()
     expect(await chanRecvWithOk(channel)).toEqual({ value: 0, ok: false })
   })