goscript 0.0.84 → 0.1.1

package/gs/builtin/builtin.ts

@@ -2,6 +2,15 @@ import type { Slice, SliceProxy } from './slice.js'
 import { writeHostStdoutText } from './hostio.js'
 import { formatPrintedArgs } from './print.js'
 import { isSliceProxy } from './slice.js'
+import { isVarRef, type VarRef } from './varRef.js'
+
+/**
+ * Implementation of Go's built-in print function
+ * @param args Arguments to print
+ */
+export function print(...args: any[]): void {
+  writeHostStdoutText(args.length === 0 ? '' : formatPrintedArgs(args))
+}
 
 /**
  * Implementation of Go's built-in println function
@@ -26,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
   }
@@ -34,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
@@ -69,13 +106,155 @@ export function assignStruct<T>(target: T, source: T): void {
   }
 }
 
+/**
+ * pointerValue unwraps a Go pointer value for generated field, method, and
+ * dereference access. Struct pointers may be represented directly as class
+ * instances or indirectly as VarRef values when the pointer came from taking a
+ * variable's address.
+ */
+export function pointerValue<T>(value: T | VarRef<T> | null | undefined): T {
+  if (value === null || value === undefined) {
+    throw new Error(
+      'runtime error: invalid memory address or nil pointer dereference',
+    )
+  }
+  if (isVarRef(value)) {
+    return value.value as 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
@@ -88,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.
  *
@@ -221,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/hostio.test.ts

@@ -1,6 +1,10 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import {
+  getHostRuntime,
+  HostRuntimeOwner,
+  type HostRuntime,
+  isMainScript,
   resetHostRuntimeForTests,
   writeHostStderrText,
   writeHostStdoutText,
@@ -10,6 +14,8 @@ const originalDeno = (globalThis as any).Deno
 const originalProcess = (globalThis as any).process
 
 afterEach(() => {
+  vi.restoreAllMocks()
+
   if (originalDeno === undefined) {
     delete (globalThis as any).Deno
   } else {
@@ -25,6 +31,40 @@ afterEach(() => {
   resetHostRuntimeForTests()
 })
 
+function runtimeFixture(platform: string): HostRuntime {
+  return {
+    deno: null,
+    getEnv: () => '',
+    getStdioHandle: () => null,
+    nodeFS: null,
+    platform,
+    processObj: null,
+    readFD: () => null,
+    writeFD: () => 0,
+    writeStderrText: () => {},
+    writeStdoutText: () => {},
+  }
+}
+
+describe('hostio runtime owner', () => {
+  it('caches host capability detection until reset', () => {
+    let detects = 0
+    const owner = new HostRuntimeOwner(() => {
+      detects++
+      return runtimeFixture(`host-${detects}`)
+    })
+
+    expect(owner.current().platform).toBe('host-1')
+    expect(owner.current().platform).toBe('host-1')
+    expect(detects).toBe(1)
+
+    owner.reset()
+
+    expect(owner.current().platform).toBe('host-2')
+    expect(detects).toBe(2)
+  })
+})
+
 describe('hostio text writes', () => {
   it('uses sync node fs writes for stdout and stderr', () => {
     const writes: Array<{ fd: number; bytes: number[] }> = []
@@ -66,4 +106,141 @@ describe('hostio text writes', () => {
     expect((globalThis as any).process.stdout.write).not.toHaveBeenCalled()
     expect((globalThis as any).process.stderr.write).not.toHaveBeenCalled()
   })
+
+  it('falls back to node fs when Deno is present without sync stdio', () => {
+    const writes: Array<{ fd: number; bytes: number[] }> = []
+    const writeSync = vi.fn(
+      (
+        fd: number,
+        buffer: Uint8Array,
+        _offset?: number,
+        length?: number,
+        _position?: number | null,
+      ) => {
+        writes.push({
+          bytes: Array.from(buffer.subarray(0, length ?? buffer.length)),
+          fd,
+        })
+        return length ?? buffer.length
+      },
+    )
+
+    ;(globalThis as any).Deno = {
+      stderr: {},
+      stdout: {},
+    }
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    writeHostStdoutText('bun\n')
+    writeHostStderrText('err\n')
+
+    expect(writeSync).toHaveBeenCalledTimes(2)
+    expect(writes).toEqual([
+      { bytes: [98, 117, 110, 10], fd: 1 },
+      { bytes: [101, 114, 114, 10], fd: 2 },
+    ])
+    expect(getHostRuntime().platform).toBe('unknown')
+  })
+
+  it('prefers Deno sync stdio when it is available', () => {
+    const denoWrites: Array<{ bytes: number[]; stream: string }> = []
+    const nodeWriteSync = vi.fn()
+    const denoWriteSync = vi.fn((buffer: Uint8Array) => {
+      denoWrites.push({
+        bytes: Array.from(buffer),
+        stream: 'stdout',
+      })
+      return buffer.length
+    })
+
+    ;(globalThis as any).Deno = {
+      build: { os: 'darwin' },
+      stdout: { writeSync: denoWriteSync },
+    }
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync: nodeWriteSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    writeHostStdoutText('deno\n')
+
+    expect(denoWriteSync).toHaveBeenCalledTimes(1)
+    expect(nodeWriteSync).not.toHaveBeenCalled()
+    expect(denoWrites).toEqual([
+      { bytes: [100, 101, 110, 111, 10], stream: 'stdout' },
+    ])
+    expect(getHostRuntime().platform).toBe('darwin')
+  })
+
+  it('uses console fallback in browser-like hosts', () => {
+    const consoleLog = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    delete (globalThis as any).Deno
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    writeHostStdoutText('browser\n')
+
+    expect(getHostRuntime().platform).toBe('unknown')
+    expect(getHostRuntime().nodeFS).toBeNull()
+    expect(consoleLog).toHaveBeenCalledWith('browser')
+  })
+})
+
+describe('hostio isMainScript', () => {
+  it('returns true when the runtime marks the module as main', () => {
+    expect(
+      isMainScript({
+        main: true,
+        url: 'file:///tmp/example.gs.ts',
+      }),
+    ).toBe(true)
+  })
+
+  it('matches process argv[1] against the module url', () => {
+    delete (globalThis as any).Deno
+    ;(globalThis as any).process = {
+      argv: ['bun', './dist/app.gs.ts'],
+      cwd: vi.fn(() => '/tmp/project'),
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync: vi.fn(),
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    expect(
+      isMainScript({
+        url: 'file:///tmp/project/dist/app.gs.ts',
+      }),
+    ).toBe(true)
+  })
+
+  it('returns false when the module was imported instead of executed', () => {
+    delete (globalThis as any).Deno
+    ;(globalThis as any).process = {
+      argv: ['bun', './runner.ts'],
+      cwd: vi.fn(() => '/tmp/project'),
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync: vi.fn(),
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    expect(
+      isMainScript({
+        url: 'file:///tmp/project/dist/app.gs.ts',
+      }),
+    ).toBe(false)
+  })
 })