goscript 0.2.5 → 0.2.7

package/gs/builtin/panic.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, it } from 'vitest'
+
+import { int64Div, pointerValue } from './builtin.js'
+import {
+  GoPanic,
+  RuntimeError,
+  panic,
+  panicValue,
+  recover,
+  recovered,
+  runtimePanic,
+} from './panic.js'
+import { goSlice, index, makeSlice } from './slice.js'
+
+// captureThrow returns whatever value the callback throws, or undefined if it
+// did not throw. Go panics surface as a thrown GoPanic in the transpiled
+// runtime, so tests assert on the caught value's shape. Catching here models a
+// program-exit boundary that fully consumes the panic, so it drains the in-flight
+// stack to keep cases independent.
+function captureThrow(fn: () => unknown): unknown {
+  try {
+    fn()
+  } catch (e) {
+    if (e instanceof GoPanic) {
+      e.recovered = true
+      recovered(e)
+    }
+    return e
+  }
+  return undefined
+}
+
+describe('runtime panics route through GoPanic', () => {
+  it('runtimePanic throws a GoPanic carrying a RuntimeError', () => {
+    const caught = captureThrow(() => runtimePanic('runtime error: boom'))
+
+    expect(caught).toBeInstanceOf(GoPanic)
+    const value = (caught as GoPanic).value
+    expect(value).toBeInstanceOf(RuntimeError)
+    // The recovered value implements the Go error interface.
+    expect((value as RuntimeError).Error()).toBe('runtime error: boom')
+    // The unrecovered crash text matches Go's "panic: <value>" shape.
+    expect((caught as GoPanic).message).toBe('panic: runtime error: boom')
+  })
+
+  it('integer divide by zero panics with the Go message', () => {
+    const caught = captureThrow(() => int64Div(1n, 0n))
+
+    expect(caught).toBeInstanceOf(GoPanic)
+    expect(((caught as GoPanic).value as RuntimeError).Error()).toBe(
+      'runtime error: integer divide by zero',
+    )
+  })
+
+  it('nil pointer dereference panics with the Go message', () => {
+    const caught = captureThrow(() => pointerValue(null))
+
+    expect(caught).toBeInstanceOf(GoPanic)
+    expect(((caught as GoPanic).value as RuntimeError).Error()).toBe(
+      'runtime error: invalid memory address or nil pointer dereference',
+    )
+  })
+
+  it('index out of range panics with the Go message', () => {
+    const caught = captureThrow(() => index(new Uint8Array([1, 2, 3]), 5))
+
+    expect(caught).toBeInstanceOf(GoPanic)
+    expect(((caught as GoPanic).value as RuntimeError).Error()).toBe(
+      'runtime error: index out of range [5] with length 3',
+    )
+  })
+
+  it('slice bounds out of range panics with the Go message', () => {
+    const caught = captureThrow(() => goSlice([1, 2, 3], 2, 1))
+
+    expect(caught).toBeInstanceOf(GoPanic)
+    expect(((caught as GoPanic).value as RuntimeError).Error()).toBe(
+      'runtime error: slice bounds out of range [2:1]',
+    )
+  })
+
+  it('makeslice with negative capacity panics with the Go message', () => {
+    const caught = captureThrow(() => makeSlice<number>(1, -1))
+
+    expect(caught).toBeInstanceOf(GoPanic)
+    expect(((caught as GoPanic).value as RuntimeError).Error()).toBe(
+      'runtime error: makeslice: cap out of range',
+    )
+  })
+
+  it('panic carries an arbitrary value that panicValue unwraps', () => {
+    const caught = captureThrow(() => panic('boom'))
+
+    expect(caught).toBeInstanceOf(GoPanic)
+    expect(panicValue(caught)).toBe('boom')
+    // panicValue passes non-panic values through unchanged.
+    expect(panicValue('plain')).toBe('plain')
+  })
+})
+
+describe('recover consumes the in-flight panic', () => {
+  // runWithRecover mirrors the code generated for a Go func that defers a
+  // function calling recover(): the deferreds run during stack unwinding (here,
+  // directly in the catch before recovered() is consulted), then recovered()
+  // decides whether the panic is swallowed or rethrown.
+  function runWithRecover(
+    body: () => void,
+    deferred: () => void,
+  ): { rethrew: unknown; finished: boolean } {
+    try {
+      body()
+    } catch (e) {
+      deferred()
+      if (!recovered(e)) {
+        // This frame is the outermost boundary in the test. In a real program an
+        // unrecovered panic propagates to the entrypoint and crashes the
+        // process, leaving nothing in flight; drain it here to model that exit
+        // so later cases start with an empty stack.
+        if (e instanceof GoPanic) {
+          e.recovered = true
+          recovered(e)
+        }
+        return { rethrew: e, finished: false }
+      }
+    }
+    return { rethrew: undefined, finished: true }
+  }
+
+  it('recover returns the panic value and swallows the panic', () => {
+    let seen: unknown = 'unset'
+    const outcome = runWithRecover(
+      () => panic('boom'),
+      () => {
+        seen = recover()
+      },
+    )
+
+    expect(seen).toBe('boom')
+    expect(outcome.finished).toBe(true)
+    expect(outcome.rethrew).toBeUndefined()
+  })
+
+  it('a deferred that does not recover lets the panic propagate', () => {
+    const outcome = runWithRecover(
+      () => panic('boom'),
+      () => {
+        // no recover() call
+      },
+    )
+
+    expect(outcome.finished).toBe(false)
+    expect(outcome.rethrew).toBeInstanceOf(GoPanic)
+    expect((outcome.rethrew as GoPanic).value).toBe('boom')
+  })
+
+  it('recover returns nil when no panic is in flight', () => {
+    expect(recover()).toBeNull()
+  })
+
+  it('recover returns nil a second time within the same panic', () => {
+    let first: unknown = 'unset'
+    let second: unknown = 'unset'
+    runWithRecover(
+      () => panic('once'),
+      () => {
+        first = recover()
+        second = recover()
+      },
+    )
+
+    expect(first).toBe('once')
+    expect(second).toBeNull()
+  })
+
+  it('recovers a runtime fault as its RuntimeError value', () => {
+    let seen: unknown = 'unset'
+    runWithRecover(
+      () => int64Div(1n, 0n),
+      () => {
+        seen = recover()
+      },
+    )
+
+    expect(seen).toBeInstanceOf(RuntimeError)
+    expect((seen as RuntimeError).Error()).toBe(
+      'runtime error: integer divide by zero',
+    )
+  })
+})

package/gs/builtin/panic.ts

@@ -0,0 +1,107 @@
+// GoPanic carries a Go panic value as it unwinds the JavaScript call stack. A
+// deferred recover() reads its value and sets recovered; an unrecovered GoPanic
+// surfaces as a thrown error whose message is "panic: <value>", matching Go's
+// crash output.
+export class GoPanic extends Error {
+  recovered = false
+
+  constructor(public readonly value: unknown) {
+    super(`panic: ${formatPanicValue(value)}`)
+  }
+}
+
+// panicStack holds the GoPanics currently unwinding the stack, innermost last.
+// panic() and runtimePanic() push before throwing; a deferred recover() consults
+// the top entry, and the recover-aware catch generated for a defer+recover
+// function removes it once handled. Empty when no panic is in flight, so a
+// recover() outside a panic returns nil.
+const panicStack: GoPanic[] = []
+
+// RuntimeError is the value carried by a panic from a Go runtime fault: index
+// out of range, slice bounds out of range, integer divide by zero, or nil
+// pointer dereference. It implements the Go error interface (Error()), so a
+// recovered runtime panic exposes the same shape as Go's runtime.Error.
+export class RuntimeError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'RuntimeError'
+  }
+
+  Error(): string {
+    return this.message
+  }
+}
+
+/**
+ * Implementation of Go's built-in panic function.
+ * @param args Arguments passed to panic
+ */
+export function panic(...args: unknown[]): never {
+  const value = args.length === 1 ? args[0] : args
+  const goPanic = new GoPanic(value)
+  panicStack.push(goPanic)
+  throw goPanic
+}
+
+// runtimePanic raises a Go runtime panic carrying a RuntimeError with the given
+// Go-formatted message (for example "runtime error: index out of range [5] with
+// length 3"). Every runtime fault routes through here so recover() observes a
+// GoPanic whose value is a runtime.Error, matching Go.
+export function runtimePanic(message: string): never {
+  const goPanic = new GoPanic(new RuntimeError(message))
+  panicStack.push(goPanic)
+  throw goPanic
+}
+
+export function panicValue(value: unknown): unknown {
+  if (value instanceof GoPanic) {
+    return value.value
+  }
+  return value
+}
+
+function formatPanicValue(value: unknown): string {
+  if (value instanceof Error) {
+    return value.message
+  }
+  if (
+    value !== null &&
+    typeof value === 'object' &&
+    'Error' in value &&
+    typeof (value as { Error?: unknown }).Error === 'function'
+  ) {
+    return String((value as { Error(): string }).Error())
+  }
+  return String(value)
+}
+
+// recover stops the in-flight panic and returns its value, matching Go's
+// built-in recover. It returns nil when no panic is unwinding (an empty stack)
+// or when the current panic was already recovered. Generated code only routes a
+// recover() call to a useful panic when it runs inside a deferred function whose
+// enclosing function is unwinding, so a recover() in ordinary control flow reads
+// an empty stack and returns nil.
+export function recover(): any {
+  const goPanic = panicStack[panicStack.length - 1]
+  if (goPanic === undefined || goPanic.recovered) {
+    return null
+  }
+  goPanic.recovered = true
+  return goPanic.value
+}
+
+// recovered reports whether err is a GoPanic that a deferred recover() consumed,
+// and removes it from the in-flight stack. The catch block generated for a
+// defer+recover function calls this: true means swallow the panic and return the
+// function's named results; false means rethrow so an outer frame can recover or
+// the program crashes with the Go panic message.
+export function recovered(err: unknown): boolean {
+  if (err instanceof GoPanic && err.recovered) {
+    const idx = panicStack.indexOf(err)
+    if (idx !== -1) {
+      panicStack.splice(idx, 1)
+    }
+    return true
+  }
+  return false
+}

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

@@ -139,8 +139,8 @@ describe('builtin runtime contract helpers', () => {
     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(uint64Div(0xffffffffffffffffn, 4114)).toBe(4483895010624587)
-    expect(uint64Mod(0xffffffffffffffffn, 4114)).toBe(697)
+    expect(uint64Div(0xffffffffffffffffn, 4114)).toBe(4483895010624587n)
+    expect(uint64Mod(0xffffffffffffffffn, 4114)).toBe(697n)
     expect(uint(uint64Add(0xffffffffffffffffn, 2), 32)).toBe(1)
     expect(uint(uint64Sub(1n, 2), 32)).toBe(0xffffffff)
     expect(uint(uint64And(0xf0n, 0x3cn), 32)).toBe(0x30)
@@ -371,8 +371,8 @@ describe('builtin runtime contract helpers', () => {
 
   it('asserts fixed-width numeric values by runtime type name', () => {
     expect(
-      typeAssertTuple<number>(13, { kind: TypeKind.Basic, name: 'uint64' }),
-    ).toEqual([13, true])
+      typeAssertTuple<bigint>(13n, { kind: TypeKind.Basic, name: 'uint64' }),
+    ).toEqual([13n, true])
     expect(
       typeAssertTuple<number>(13, { kind: TypeKind.Basic, name: 'int32' }),
     ).toEqual([13, true])
@@ -530,7 +530,7 @@ describe('builtin runtime contract helpers', () => {
     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',
+      'cannot convert slice with length 2 to array or pointer to array with length 3',
     )
 
     expect(sliceToArray<number>(new Uint8Array([4, 5, 6]), 2, 'byte')).toEqual(

package/gs/builtin/slice.test.ts

@@ -7,12 +7,35 @@ import {
   copy,
   indexString,
   len,
+  runeToString,
+  runesToString,
   sliceString,
   stringCompare,
   stringEqual,
   stringToBytes,
 } from './slice.js'
 
+describe('rune to string encoding (Go string(rune) semantics)', () => {
+  it('preserves astral-plane runes above U+FFFF', () => {
+    // U+1F600 grinning face; fromCharCode would have truncated to a broken unit.
+    expect(runeToString(0x1f600)).toBe('😀')
+    expect(runeToString(0x1f600).codePointAt(0)).toBe(0x1f600)
+    // CJU+597D '好'
+    expect(runeToString(0x597d)).toBe('好')
+  })
+
+  it('maps invalid and surrogate runes to U+FFFD, never throwing', () => {
+    expect(runeToString(-1)).toBe('�')
+    expect(runeToString(0x110000)).toBe('�')
+    expect(runeToString(0xd800)).toBe('�')
+  })
+
+  it('encodes a rune slice with astral planes intact', () => {
+    expect(runesToString([0x48, 0x69, 0x1f600] as never)).toBe('Hi😀')
+    expect(runesToString([] as never)).toBe('')
+  })
+})
+
 describe('builtin string byte representation', () => {
   it('appends large byte slices without JavaScript argument spreading', () => {
     const dst = new Uint8Array(0)