goscript 0.2.5 → 0.2.7

package/gs/builtin/slice.ts

@@ -1,3 +1,4 @@
+import { runtimePanic } from './panic.js'
 import {
   isOwnedPointerHandle,
   isVarRef,
@@ -123,6 +124,18 @@ export type Slice<T> =
   | null
   | (T extends number ? Uint8Array : never)
 
+// outOfRangeIndex panics with Go's index-out-of-range runtime message. Go omits
+// the "with length" suffix for negative indices and includes it otherwise, so
+// callers route every element bounds failure through here to stay byte-faithful.
+function outOfRangeIndex(index: number, length: number): never {
+  if (index < 0) {
+    runtimePanic(`runtime error: index out of range [${index}]`)
+  }
+  runtimePanic(
+    `runtime error: index out of range [${index}] with length ${length}`,
+  )
+}
+
 /**
  * wrapSliceProxy wraps a SliceProxy in a Proxy to intercept index access
  * and route it through the backing array.
@@ -137,7 +150,7 @@ function wrapSliceProxy<T>(proxy: SliceProxy<T>): SliceProxy<T> {
         if (index < meta.length) {
           return meta.backing[meta.offset + index]
         }
-        throw new Error(`Slice index out of range: ${index} >= ${meta.length}`)
+        outOfRangeIndex(index, meta.length)
       }
 
       if (prop === 'length') {
@@ -159,7 +172,7 @@ function wrapSliceProxy<T>(proxy: SliceProxy<T>): SliceProxy<T> {
           target[index] = value // Also update the proxy target for consistency
           return true
         }
-        throw new Error(`Slice index out of range: ${index} >= ${meta.length}`)
+        outOfRangeIndex(index, meta.length)
       }
 
       if (prop === 'length' || prop === '__meta__') {
@@ -222,8 +235,8 @@ export function sliceToArray<T>(
   typeHint?: string,
 ): T[] | Uint8Array {
   if (len(slice) < length) {
-    throw new Error(
-      `runtime error: cannot convert slice with length ${len(slice)} to array with length ${length}`,
+    runtimePanic(
+      `runtime error: cannot convert slice with length ${len(slice)} to array or pointer to array with length ${length}`,
     )
   }
   if (typeHint === 'byte') {
@@ -240,8 +253,8 @@ export function sliceToArrayPointer<T>(
   typeHint?: string,
 ): VarRef<T[] | Uint8Array> {
   if (len(slice) < length) {
-    throw new Error(
-      `runtime error: cannot convert slice with length ${len(slice)} to array pointer with length ${length}`,
+    runtimePanic(
+      `runtime error: cannot convert slice with length ${len(slice)} to array or pointer to array with length ${length}`,
     )
   }
   if (typeHint === 'byte') {
@@ -323,8 +336,10 @@ export const makeSlice = <T>(
   if (typeHint === 'byte') {
     const actualCapacity = capacity === undefined ? length : capacity
     if (length < 0 || actualCapacity < 0 || length > actualCapacity) {
-      throw new Error(
-        `Invalid slice length (${length}) or capacity (${actualCapacity})`,
+      runtimePanic(
+        actualCapacity < 0 ?
+          'runtime error: makeslice: cap out of range'
+        : 'runtime error: makeslice: len out of range',
       )
     }
 
@@ -343,8 +358,10 @@ export const makeSlice = <T>(
 
   const actualCapacity = capacity === undefined ? length : capacity
   if (length < 0 || actualCapacity < 0 || length > actualCapacity) {
-    throw new Error(
-      `Invalid slice length (${length}) or capacity (${actualCapacity})`,
+    runtimePanic(
+      actualCapacity < 0 ?
+        'runtime error: makeslice: cap out of range'
+      : 'runtime error: makeslice: len out of range',
     )
   }
 
@@ -399,7 +416,7 @@ export const makeSlice = <T>(
         if (index < target.__meta__.length) {
           return target.__meta__.backing[target.__meta__.offset + index]
         }
-        throw new Error(
+        runtimePanic(
           `Slice index out of range: ${index} >= ${target.__meta__.length}`,
         )
       }
@@ -423,7 +440,7 @@ export const makeSlice = <T>(
           target[index] = value // Also update the proxy target for consistency
           return true
         }
-        throw new Error(
+        runtimePanic(
           `Slice index out of range: ${index} >= ${target.__meta__.length}`,
         )
       }
@@ -480,7 +497,7 @@ export function goSlice<T>( // T can be number for Uint8Array case
         if (index < target.__meta__.length) {
           return target.__meta__.backing[target.__meta__.offset + index]
         }
-        throw new Error(
+        runtimePanic(
           `Slice index out of range: ${index} >= ${target.__meta__.length}`,
         )
       }
@@ -528,7 +545,7 @@ export function goSlice<T>( // T can be number for Uint8Array case
           target.__meta__.length++
           return true
         }
-        throw new Error(
+        runtimePanic(
           `Slice index out of range: ${index} >= ${target.__meta__.length}`,
         )
       }
@@ -556,8 +573,8 @@ export function goSlice<T>( // T can be number for Uint8Array case
       actualLow > baseCapacity ||
       actualHigh > baseCapacity
     ) {
-      throw new Error(
-        `Invalid slice indices: low ${actualLow}, high ${actualHigh} for Uint8Array with capacity ${baseCapacity}`,
+      runtimePanic(
+        `runtime error: slice bounds out of range [${actualLow}:${actualHigh}] with capacity ${baseCapacity}`,
       )
     }
 
@@ -566,8 +583,8 @@ export function goSlice<T>( // T can be number for Uint8Array case
     if (max !== undefined) {
       if (max < actualHigh || max > baseCapacity) {
         // max is relative to the original s.length (capacity)
-        throw new Error(
-          `Invalid max index: ${max}. Constraints: low ${actualLow} <= high ${actualHigh} <= max <= capacity ${baseCapacity}`,
+        runtimePanic(
+          `runtime error: slice bounds out of range [:${actualHigh}:${max}] with capacity ${baseCapacity}`,
         )
       }
 
@@ -594,17 +611,17 @@ export function goSlice<T>( // T can be number for Uint8Array case
     high = high ?? 0
 
     if (low < 0 || high < low) {
-      throw new Error(`Invalid slice indices: ${low}:${high}`)
+      runtimePanic(`runtime error: slice bounds out of range [${low}:${high}]`)
     }
 
     if (low !== 0 || high !== 0) {
-      throw new Error(
+      runtimePanic(
         `runtime error: slice bounds out of range [:${high}] with capacity 0`,
       )
     }
 
     if (max !== undefined && max !== 0) {
-      throw new Error(
+      runtimePanic(
         `runtime error: slice bounds out of range [::${max}] with capacity 0`,
       )
     }
@@ -617,13 +634,13 @@ export function goSlice<T>( // T can be number for Uint8Array case
   high = high ?? slen
 
   if (low < 0 || high < low) {
-    throw new Error(`Invalid slice indices: ${low}:${high}`)
+    runtimePanic(`runtime error: slice bounds out of range [${low}:${high}]`)
   }
 
   // In Go, high can be up to capacity, not just length
   const scap = cap(s)
   if (high > scap) {
-    throw new Error(`Slice index out of range: ${high} > ${scap}`)
+    runtimePanic(`Slice index out of range: ${high} > ${scap}`)
   }
 
   if (
@@ -652,15 +669,13 @@ export function goSlice<T>( // T can be number for Uint8Array case
   let newCap
   if (max !== undefined) {
     if (max < high) {
-      throw new Error(`Invalid slice indices: ${low}:${high}:${max}`)
+      runtimePanic(`runtime error: slice bounds out of range [:${high}:${max}]`)
     }
     if (isComplexSlice(s) && max > oldOffset + oldCap) {
-      throw new Error(
-        `Slice index out of range: ${max} > ${oldOffset + oldCap}`,
-      )
+      runtimePanic(`Slice index out of range: ${max} > ${oldOffset + oldCap}`)
     }
     if (!isComplexSlice(s) && max > s.length) {
-      throw new Error(`Slice index out of range: ${max} > ${s.length}`)
+      runtimePanic(`Slice index out of range: ${max} > ${s.length}`)
     }
     newCap = max - low
   } else {
@@ -735,7 +750,7 @@ export const arrayToSlice = <T>(
         if (index < target.__meta__.length) {
           return target.__meta__.backing[target.__meta__.offset + index]
         }
-        throw new Error(
+        runtimePanic(
           `Slice index out of range: ${index} >= ${target.__meta__.length}`,
         )
       }
@@ -781,7 +796,7 @@ export const arrayToSlice = <T>(
           target.__meta__.length++
           return true
         }
-        throw new Error(
+        runtimePanic(
           `Slice index out of range: ${index} >= ${target.__meta__.length}`,
         )
       }
@@ -1330,34 +1345,66 @@ export function index<T>(
   index: number,
 ): T | number {
   if (collection === null || collection === undefined) {
-    throw new Error('runtime error: index on nil or undefined collection')
+    runtimePanic('runtime error: index on nil or undefined collection')
   }
 
   if (isGoStringValue(collection)) {
     return indexString(collection, index) // Use the existing indexString for byte access
   } else if (collection instanceof Uint8Array) {
     if (index < 0 || index >= collection.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.length}`,
-      )
+      outOfRangeIndex(index, collection.length)
     }
     return collection[index]
   } else if (isComplexSlice(collection)) {
     if (index < 0 || index >= collection.__meta__.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.__meta__.length}`,
-      )
+      outOfRangeIndex(index, collection.__meta__.length)
     }
     return collection.__meta__.backing[collection.__meta__.offset + index]
   } else if (Array.isArray(collection)) {
     if (index < 0 || index >= collection.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.length}`,
-      )
+      outOfRangeIndex(index, collection.length)
     }
     return collection[index]
   }
-  throw new Error('runtime error: index on unsupported type')
+  runtimePanic('runtime error: index on unsupported type')
+}
+
+/**
+ * arrayIndex reads collection[index] with Go bounds-check semantics, panicking
+ * with the Go runtime message when index is out of range. Strings and maps are
+ * lowered through their own helpers, so this covers Go arrays and slices. The
+ * overloads reproduce the element type of a direct collection[index]: a byte
+ * collection yields number, an element slice yields its element type.
+ */
+export function arrayIndex(collection: Uint8Array, index: number): number
+export function arrayIndex<T>(collection: Slice<T> | T[], index: number): T
+export function arrayIndex<T>(
+  collection: Slice<T> | T[] | Uint8Array,
+  index: number,
+): T | number {
+  if (collection === null || collection === undefined) {
+    outOfRangeIndex(index, 0)
+  }
+  if (collection instanceof Uint8Array) {
+    if (index < 0 || index >= collection.length) {
+      outOfRangeIndex(index, collection.length)
+    }
+    return collection[index]
+  }
+  if (isComplexSlice(collection)) {
+    const length = collection.__meta__.length
+    if (index < 0 || index >= length) {
+      outOfRangeIndex(index, length)
+    }
+    return collection.__meta__.backing[collection.__meta__.offset + index]
+  }
+  if (Array.isArray(collection)) {
+    if (index < 0 || index >= collection.length) {
+      outOfRangeIndex(index, collection.length)
+    }
+    return collection[index]
+  }
+  runtimePanic('runtime error: index on unsupported type')
 }
 
 /**
@@ -1368,13 +1415,11 @@ export function indexRef<T>(
   index: number,
 ): VarRef<T> {
   if (collection === null || collection === undefined) {
-    throw new Error('runtime error: index on nil or undefined collection')
+    runtimePanic('runtime error: index on nil or undefined collection')
   }
   if (collection instanceof Uint8Array) {
     if (index < 0 || index >= collection.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.length}`,
-      )
+      outOfRangeIndex(index, collection.length)
     }
     const ref: VarRef<T> = {
       get value() {
@@ -1393,9 +1438,7 @@ export function indexRef<T>(
   }
   if (isComplexSlice(collection)) {
     if (index < 0 || index >= collection.__meta__.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.__meta__.length}`,
-      )
+      outOfRangeIndex(index, collection.__meta__.length)
     }
     const backingIndex = collection.__meta__.offset + index
     const ref: VarRef<T> = {
@@ -1415,9 +1458,7 @@ export function indexRef<T>(
   }
   if (Array.isArray(collection)) {
     if (index < 0 || index >= collection.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.length}`,
-      )
+      outOfRangeIndex(index, collection.length)
     }
     const ref: VarRef<T> = {
       get value() {
@@ -1434,7 +1475,7 @@ export function indexRef<T>(
     ref.__goPointer = collectionPointer(ref, collection, index)
     return ref
   }
-  throw new Error('runtime error: index on unsupported type')
+  runtimePanic('runtime error: index on unsupported type')
 }
 
 function collectionPointer<T>(
@@ -1448,7 +1489,7 @@ function collectionPointer<T>(
     __goRef: () => ref,
     __goSlice: (length: number) => {
       if (length < 0) {
-        throw new Error('runtime error: unsafe slice length out of range')
+        runtimePanic('runtime error: unsafe slice length out of range')
       }
       return goSlice(collection as any, index, index + length, index + length)
     },
@@ -1517,7 +1558,7 @@ export function indexAddress<T>(
   index: number,
 ): number {
   if (collection === null || collection === undefined) {
-    throw new Error('runtime error: index on nil or undefined collection')
+    runtimePanic('runtime error: index on nil or undefined collection')
   }
 
   let backing: object
@@ -1536,13 +1577,11 @@ export function indexAddress<T>(
     backingIndex = index
     length = collection.length
   } else {
-    throw new Error('runtime error: index on unsupported type')
+    runtimePanic('runtime error: index on unsupported type')
   }
 
   if (index < 0 || index >= length) {
-    throw new Error(
-      `runtime error: index out of range [${index}] with length ${length}`,
-    )
+    outOfRangeIndex(index, length)
   }
 
   let base = addressBases.get(backing)
@@ -1619,14 +1658,12 @@ export function indexByteAddress<T>(
   elementByteSize: number,
 ): number {
   if (collection === null || collection === undefined) {
-    throw new Error('runtime error: index on nil or undefined collection')
+    runtimePanic('runtime error: index on nil or undefined collection')
   }
 
   if (collection instanceof Uint8Array) {
     if (index < 0 || index >= collection.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.length}`,
-      )
+      outOfRangeIndex(index, collection.length)
     }
     const view = new Uint8Array(collection.buffer)
     const base = byteAddressBase(collection.buffer, {
@@ -1643,9 +1680,7 @@ export function indexByteAddress<T>(
 
   if (isComplexSlice(collection)) {
     if (index < 0 || index >= collection.__meta__.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.__meta__.length}`,
-      )
+      outOfRangeIndex(index, collection.__meta__.length)
     }
     const backing = collection.__meta__.backing as unknown as number[]
     const byteSize = Math.max(1, Math.trunc(elementByteSize))
@@ -1655,9 +1690,7 @@ export function indexByteAddress<T>(
 
   if (Array.isArray(collection)) {
     if (index < 0 || index >= collection.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${collection.length}`,
-      )
+      outOfRangeIndex(index, collection.length)
     }
     const byteSize = Math.max(1, Math.trunc(elementByteSize))
     const base = byteAddressBase(
@@ -1667,7 +1700,7 @@ export function indexByteAddress<T>(
     return base + index * byteSize
   }
 
-  throw new Error('runtime error: index on unsupported type')
+  runtimePanic('runtime error: index on unsupported type')
 }
 
 /**
@@ -1685,7 +1718,7 @@ export function unsafePointerRef<T>(address: number | bigint): VarRef<T> {
   }
   const offset = numericAddress - base
   if (offset < 0 || offset >= source.byteLength) {
-    throw new Error('runtime error: unsafe pointer address out of range')
+    runtimePanic('runtime error: unsafe pointer address out of range')
   }
   return {
     get value(): T {
@@ -1709,7 +1742,7 @@ function byteArrayFromAddress(
       const index = sliceIndexProperty(prop)
       if (index >= 0) {
         if (index >= length) {
-          throw new Error(`Slice index out of range: ${index} >= ${length}`)
+          runtimePanic(`Slice index out of range: ${index} >= ${length}`)
         }
         return unsafePointerRef<number>(start + index).value
       }
@@ -1719,7 +1752,7 @@ function byteArrayFromAddress(
       const index = sliceIndexProperty(prop)
       if (index >= 0) {
         if (index >= length) {
-          throw new Error(`Slice index out of range: ${index} >= ${length}`)
+          runtimePanic(`Slice index out of range: ${index} >= ${length}`)
         }
         unsafePointerRef<number>(start + index).value = value
         return true
@@ -1773,7 +1806,26 @@ export const stringToRune = (str: string): number => {
  * @returns The resulting string.
  */
 export const runesToString = (runes: Slice<number>): string => {
-  return runes?.length ? String.fromCharCode(...runes) : ''
+  if (!runes?.length) {
+    return ''
+  }
+  let out = ''
+  for (const r of runes) {
+    out += runeToString(r)
+  }
+  return out
+}
+
+// runeToString encodes one rune as Go's string(rune) does: a valid Unicode
+// scalar value becomes its character including code points above U+FFFF (astral
+// planes), and a negative, out-of-range, or surrogate rune becomes U+FFFD
+// (utf8.RuneError), never a throw. String.fromCharCode truncated astral runes to
+// a single broken UTF-16 unit; String.fromCodePoint preserves the full rune.
+export function runeToString(r: number): string {
+  if (r < 0 || r > 0x10ffff || (r >= 0xd800 && r <= 0xdfff)) {
+    return '�'
+  }
+  return String.fromCodePoint(r)
 }
 
 /**
@@ -1802,30 +1854,22 @@ export const indexString = (
     // Bytes - access directly
     if (str instanceof Uint8Array) {
       if (index < 0 || index >= str.length) {
-        throw new Error(
-          `runtime error: index out of range [${index}] with length ${str.length}`,
-        )
+        outOfRangeIndex(index, str.length)
       }
       return str[index]
     }
     // Array or null
     if (str === null || str === undefined) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length 0`,
-      )
+      outOfRangeIndex(index, 0)
     }
     if (index < 0 || index >= str.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${str.length}`,
-      )
+      outOfRangeIndex(index, str.length)
     }
     return str[index]
   }
   const bytes = goStringBytes(str)
   if (index < 0 || index >= bytes.length) {
-    throw new Error(
-      `runtime error: index out of range [${index}] with length ${bytes.length}`,
-    )
+    outOfRangeIndex(index, bytes.length)
   }
   return bytes[index]
 }
@@ -1871,7 +1915,7 @@ export const sliceString = (
     ) {
       return ''
     }
-    throw new Error(
+    runtimePanic(
       `runtime error: slice bounds out of range [${actualLow}:${actualHigh}] with length ${bytes.length}`,
     )
   }
@@ -2142,22 +2186,16 @@ export function indexStringOrBytes(
   } else if (value instanceof Uint8Array) {
     // For Uint8Array, direct access returns the byte value
     if (index < 0 || index >= value.length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${value.length}`,
-      )
+      outOfRangeIndex(index, value.length)
     }
     return value[index]
   } else if (value === null) {
-    throw new Error(
-      `runtime error: index out of range [${index}] with length 0`,
-    )
+    outOfRangeIndex(index, 0)
   } else {
     // For Slice<number> (including SliceProxy)
     const length = len(value)
     if (index < 0 || index >= length) {
-      throw new Error(
-        `runtime error: index out of range [${index}] with length ${length}`,
-      )
+      outOfRangeIndex(index, length)
     }
     return (value as any)[index] as number
   }

package/gs/builtin/type.ts

@@ -285,6 +285,19 @@ export const registerInterfaceType = (
   return typeInfo
 }
 
+// The builtin error interface is predeclared in Go. Register it so a bare
+// "error" type assertion (x.(error)), which the compiler emits by the universe
+// type name, resolves to its method set instead of an unmatched basic type. Any
+// value with an Error() string method, including recovered runtime panics,
+// then satisfies it.
+registerInterfaceType('error', null, [
+  {
+    name: 'Error',
+    args: [],
+    returns: [{ type: { kind: TypeKind.Basic, name: 'string' } }],
+  },
+])
+
 /**
  * Gets a registered type by name from the type registry.
  * Returns undefined if the type is not registered.
@@ -632,20 +645,20 @@ function validateMapKey(key: any, keyTypeInfo: TypeInfo): boolean {
  */
 function matchesBasicType(value: any, info: TypeInfo): boolean {
   if (info.name === 'string') return typeof value === 'string'
+  if (info.name === 'int64' || info.name === 'uint64')
+    return typeof value === 'bigint'
   if (
     info.name === 'number' ||
     info.name === 'int' ||
     info.name === 'int8' ||
     info.name === 'int16' ||
     info.name === 'int32' ||
-    info.name === 'int64' ||
     info.name === 'uint' ||
+    info.name === 'uintptr' ||
     info.name === 'uint8' ||
     info.name === 'byte' ||
     info.name === 'uint16' ||
     info.name === 'uint32' ||
-    info.name === 'uint64' ||
-    info.name === 'uintptr' ||
     info.name === 'float32' ||
     info.name === 'float64'
   )

package/gs/builtin/varRef.ts

@@ -1,3 +1,5 @@
+import { runtimePanic } from './panic.js'
+
 export interface OwnedPointerHandle<T = unknown> {
   readonly __goOwnedPointer: true
   __goAddress: () => number
@@ -126,10 +128,10 @@ export function ownedPointerRef<T>(pointer: OwnedPointerHandle<T>): VarRef<T> {
   return pointer.__goRef()
 }
 
-/** Dereference a variable reference, throws on null → simulates Go panic. */
+/** Dereference a variable reference; a null ref raises a Go runtime panic. */
 export function unref<T>(b: VarRef<T>): T {
   if (b === null) {
-    throw new Error(
+    runtimePanic(
       'runtime error: invalid memory address or nil pointer dereference',
     )
   }

package/gs/builtin/wide-int.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+
+import { uint, uint64, uint64Add, uint64Shr } from './builtin.js'
+
+// Go represents uint/uintptr as a TypeScript number, but values above 2^53
+// cannot round-trip through a JS number. uint() keeps those as a runtime bigint
+// (typed number) so full 64-bit width survives, matching Go semantics such as
+// ^uint(0) == 2^64-1. int64/uint64 stay bigint unconditionally.
+describe('uint full 64-bit width (Go uint semantics)', () => {
+  const maxUint = 18446744073709551615n // ^uint(0)
+
+  it('preserves ^uint(0) without precision loss', () => {
+    const v = uint(maxUint, 64)
+    expect(v).toBe(maxUint as unknown as number)
+  })
+
+  it('keeps small uint values as plain numbers', () => {
+    expect(uint(5n, 64)).toBe(5)
+    expect(typeof uint(5n, 64)).toBe('number')
+    expect(typeof uint(maxUint, 64)).toBe('bigint')
+  })
+
+  it('right-shifting ^uint(0) yields a 64-bit-wide result, not 0 or 1', () => {
+    // uintBitLen-style loop: repeated >>1 from 2^64-1 must count 64 bits.
+    let n: number | bigint = uint(maxUint, 64)
+    let bits = 0
+    while ((n as bigint) !== 0n && (n as number) !== 0) {
+      bits++
+      n = uint(uint64Shr(n, 1), 64)
+    }
+    expect(bits).toBe(64)
+  })
+
+  it('uint64 modular wraparound preserves full width', () => {
+    // (2^64-1) + 1 wraps to 0 under uint64.
+    expect(uint64Add(maxUint, 1n)).toBe(0n)
+    // uint64 always yields bigint regardless of magnitude.
+    expect(uint64(7)).toBe(7n)
+    expect(typeof uint64(7)).toBe('bigint')
+  })
+})