goscript 0.1.1 → 0.1.2

package/gs/builtin/builtin.ts

@@ -21,12 +21,41 @@ export function println(...args: any[]): void {
   writeHostStdoutText(message)
 }
 
+export class GoPanic extends Error {
+  constructor(public readonly value: unknown) {
+    super(`panic: ${formatPanicValue(value)}`)
+  }
+}
+
 /**
  * Implementation of Go's built-in panic function
  * @param args Arguments passed to panic
  */
-export function panic(...args: any[]): never {
-  throw new Error(`panic: ${args.map((arg) => String(arg)).join(' ')}`)
+export function panic(...args: unknown[]): never {
+  const value = args.length === 1 ? args[0] : args
+  throw new GoPanic(value)
+}
+
+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)
 }
 
 /**
@@ -121,6 +150,46 @@ export function pointerValue<T>(value: T | VarRef<T> | null | undefined): T {
   if (isVarRef(value)) {
     return value.value as T
   }
+  const boxed =
+    typeof value === 'object' &&
+    value !== null &&
+    '__goValue' in value ?
+      (value as { __goType?: unknown; __goValue: T | VarRef<T> })
+    : null
+  if (
+    boxed !== null &&
+    typeof boxed.__goType === 'string' &&
+    boxed.__goType.startsWith('*') &&
+    !hasGoMethodSurface(value)
+  ) {
+    return pointerValue(boxed.__goValue)
+  }
+  return value
+}
+
+export function pointerValueOrNil<T>(
+  value: T | VarRef<T> | null | undefined,
+): T | null {
+  if (value === null || value === undefined) {
+    return null
+  }
+  if (isVarRef(value)) {
+    return value.value as T
+  }
+  const boxed =
+    typeof value === 'object' &&
+    value !== null &&
+    '__goValue' in value ?
+      (value as { __goType?: unknown; __goValue: T | VarRef<T> })
+    : null
+  if (
+    boxed !== null &&
+    typeof boxed.__goType === 'string' &&
+    boxed.__goType.startsWith('*') &&
+    !hasGoMethodSurface(value)
+  ) {
+    return pointerValueOrNil(boxed.__goValue)
+  }
   return value
 }
 
@@ -128,7 +197,7 @@ export function arrayEqual(a: unknown, b: unknown): boolean {
   return comparableEqual(a, b)
 }
 
-function comparableEqual(a: unknown, b: unknown): boolean {
+export function comparableEqual(a: unknown, b: unknown): boolean {
   if (a === b) {
     return true
   }
@@ -146,6 +215,14 @@ function comparableEqual(a: unknown, b: unknown): boolean {
     }
     return true
   }
+  if (isComplexValue(a) || isComplexValue(b)) {
+    return (
+      isComplexValue(a) &&
+      isComplexValue(b) &&
+      a.real === b.real &&
+      a.imag === b.imag
+    )
+  }
   if (hasGoType(a) || hasGoType(b)) {
     if (!hasGoType(a) || !hasGoType(b) || a.__goType !== b.__goType) {
       return false
@@ -153,6 +230,9 @@ function comparableEqual(a: unknown, b: unknown): boolean {
     if (a.__isTypedNil || b.__isTypedNil) {
       return a.__isTypedNil === true && b.__isTypedNil === true
     }
+    if (hasGoValue(a) || hasGoValue(b)) {
+      return hasGoValue(a) && hasGoValue(b) && comparableEqual(a.__goValue, b.__goValue)
+    }
   }
   if (isStructValue(a) && isStructValue(b)) {
     return fieldsEqual(a._fields, b._fields)
@@ -175,14 +255,39 @@ function hasGoType(value: unknown): value is {
   )
 }
 
+function hasGoValue(value: unknown): value is {
+  __goValue: unknown
+} {
+  return typeof value === 'object' && value !== null && '__goValue' in value
+}
+
+function hasGoMethodSurface(value: unknown): boolean {
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+  return Object.keys(value).some((key) => {
+    return (
+      key !== '__goType' &&
+      key !== '__goValue' &&
+      key !== 'valueOf' &&
+      key !== 'toString' &&
+      typeof (value as Record<string, unknown>)[key] === 'function'
+    )
+  })
+}
+
 function isStructValue(value: unknown): value is {
   _fields: Record<string, VarRef<unknown>>
 } {
+  const fields =
+    typeof value === 'object' && value !== null ?
+      (value as { _fields?: unknown })._fields
+    : undefined
   return (
-    typeof value === 'object' &&
-    value !== null &&
-    typeof (value as { _fields?: unknown })._fields === 'object' &&
-    (value as { _fields?: unknown })._fields !== null
+    typeof fields === 'object' &&
+    fields !== null &&
+    !Array.isArray(fields) &&
+    Object.values(fields).every(isVarRef)
   )
 }
 
@@ -208,6 +313,15 @@ export interface Complex {
   imag: number
 }
 
+function isComplexValue(value: unknown): value is Complex {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { real?: unknown }).real === 'number' &&
+    typeof (value as { imag?: unknown }).imag === 'number'
+  )
+}
+
 export function complex(real: number, imag: number): Complex {
   return { real, imag }
 }
@@ -229,6 +343,10 @@ export function imag(value: number | Complex | null | undefined): number {
 // 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>
+type ByteData = Uint8Array | number[] | SliceProxy<number>
+
+const maxSafeBigInt = BigInt(Number.MAX_SAFE_INTEGER)
+const maxUint64BigInt = 0xffffffffffffffffn
 
 // 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
@@ -272,15 +390,30 @@ 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 uint64Result(normalized)
     }
     return Number(normalized)
   }
+  if (!Number.isFinite(value)) {
+    return value
+  }
+  if (bits === 8) {
+    return value & 0xff
+  }
+  if (bits === 16) {
+    return value & 0xffff
+  }
+  if (bits === 32) {
+    return value >>> 0
+  }
+  if (bits >= 64) {
+    const truncated = Math.trunc(value)
+    if (truncated >= 0 && truncated <= Number.MAX_SAFE_INTEGER) {
+      return truncated
+    }
+  }
   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
@@ -288,14 +421,34 @@ export function uint(value: number | bigint, bits = 64): number {
   return truncated
 }
 
-export function uint64Shl(value: number | bigint, shift: number | bigint): number {
+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 {
+export function uint64Shr(
+  value: number | bigint,
+  shift: number | bigint,
+): number {
   return uint64Result(uint64Value(value) >> BigInt(Math.trunc(Number(shift))))
 }
 
+export function int64Shl(
+  value: number | bigint,
+  shift: number | bigint,
+): number {
+  return int64Result(int64Value(value) << BigInt(Math.trunc(Number(shift))))
+}
+
+export function int64Shr(
+  value: number | bigint,
+  shift: number | bigint,
+): number {
+  return int64Result(int64Value(value) >> BigInt(Math.trunc(Number(shift))))
+}
+
 export function uintShr(
   value: number | bigint,
   shift: number | bigint,
@@ -312,39 +465,178 @@ export function uintShr(
   return uint(value, width) >>> amount
 }
 
-export function uint64Mul(left: number | bigint, right: number | bigint): number {
+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 {
+export function int64Mul(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) * int64Value(right))
+}
+
+export function uint64Div(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  const divisor = uint64Value(right)
+  if (divisor === 0n) {
+    throw new Error('runtime error: integer divide by zero')
+  }
+  return uint64Result(uint64Value(left) / divisor)
+}
+
+export function int64Div(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  const divisor = int64Value(right)
+  if (divisor === 0n) {
+    throw new Error('runtime error: integer divide by zero')
+  }
+  return int64Result(int64Value(left) / divisor)
+}
+
+export function uint64Mod(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  const divisor = uint64Value(right)
+  if (divisor === 0n) {
+    throw new Error('runtime error: integer divide by zero')
+  }
+  return uint64Result(uint64Value(left) % divisor)
+}
+
+export function int64Mod(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  const divisor = int64Value(right)
+  if (divisor === 0n) {
+    throw new Error('runtime error: integer divide by zero')
+  }
+  return int64Result(int64Value(left) % divisor)
+}
+
+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 {
+export function int64Add(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) + int64Value(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 {
+export function int64Sub(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) - int64Value(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 {
+export function int64And(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) & int64Value(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 {
+export function int64Or(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) | int64Value(right))
+}
+
+export function uint64Xor(
+  left: number | bigint,
+  right: number | bigint,
+): number {
   return uint64Result(uint64Value(left) ^ uint64Value(right))
 }
 
+export function int64Xor(
+  left: number | bigint,
+  right: number | bigint,
+): number {
+  return int64Result(int64Value(left) ^ int64Value(right))
+}
+
+function int64Value(value: number | bigint): bigint {
+  if (typeof value === 'bigint') {
+    return BigInt.asIntN(64, value)
+  }
+  if (Number.isFinite(value)) {
+    const truncated = Math.trunc(value)
+    if (
+      truncated >= Number.MIN_SAFE_INTEGER &&
+      truncated <= Number.MAX_SAFE_INTEGER
+    ) {
+      return BigInt(truncated)
+    }
+  }
+  return BigInt.asIntN(64, BigInt(Math.trunc(value)))
+}
+
+function int64Result(value: bigint): number {
+  const normalized =
+    value >= -0x8000000000000000n && value <= 0x7fffffffffffffffn
+      ? value
+      : BigInt.asIntN(64, value)
+  return Number(normalized)
+}
+
 function uint64Value(value: number | bigint): bigint {
   if (typeof value === 'bigint') {
     return BigInt.asUintN(64, value)
   }
+  if (Number.isFinite(value)) {
+    const truncated = Math.trunc(value)
+    if (truncated >= 0 && truncated <= Number.MAX_SAFE_INTEGER) {
+      return BigInt(truncated)
+    }
+  }
   return BigInt.asUintN(64, BigInt(Math.trunc(value)))
 }
 
 function uint64Result(value: bigint): number {
-  return BigInt.asUintN(64, value) as unknown as number
+  const normalized =
+    value >= 0n && value <= maxUint64BigInt ? value : BigInt.asUintN(64, value)
+  if (normalized <= maxSafeBigInt) {
+    return Number(normalized)
+  }
+  return normalized as unknown as number
 }
 
 /**
@@ -428,18 +720,15 @@ export function sortSlice<T extends string | number>(s: Slice<T>): void {
  * Optimized for different byte representations.
  */
 export function bytesEqual(a: Bytes | null, b: Bytes | null): boolean {
-  // Handle null cases
   if (a === null && b === null) return true
   if (a === null || b === null) return false
 
-  // Convert to arrays for comparison
-  const aArr = bytesToArray(a)
-  const bArr = bytesToArray(b)
-
-  if (aArr.length !== bArr.length) return false
+  const aLen = bytesLen(a)
+  const bLen = bytesLen(b)
+  if (aLen !== bLen) return false
 
-  for (let i = 0; i < aArr.length; i++) {
-    if (aArr[i] !== bArr[i]) return false
+  for (let i = 0; i < aLen; i++) {
+    if (byteAt(a, i) !== byteAt(b, i)) return false
   }
 
   return true
@@ -450,30 +739,49 @@ export function bytesEqual(a: Bytes | null, b: Bytes | null): boolean {
  * Returns -1 if a < b, 0 if a == b, +1 if a > b.
  */
 export function bytesCompare(a: Bytes | null, b: Bytes | null): number {
-  // Handle null cases
   if (a === null && b === null) return 0
   if (a === null) return -1
   if (b === null) return 1
 
-  const aArr = bytesToArray(a)
-  const bArr = bytesToArray(b)
-
-  const minLen = Math.min(aArr.length, bArr.length)
+  const aLen = bytesLen(a)
+  const bLen = bytesLen(b)
+  const minLen = Math.min(aLen, bLen)
 
   for (let i = 0; i < minLen; i++) {
-    if (aArr[i] < bArr[i]) return -1
-    if (aArr[i] > bArr[i]) return 1
+    const av = byteAt(a, i)
+    const bv = byteAt(b, i)
+    if (av < bv) return -1
+    if (av > bv) return 1
   }
 
-  if (aArr.length < bArr.length) return -1
-  if (aArr.length > bArr.length) return 1
+  if (aLen < bLen) return -1
+  if (aLen > bLen) return 1
   return 0
 }
 
+function bytesLen(bytes: ByteData): number {
+  if (bytes instanceof Uint8Array) {
+    return bytes.length
+  }
+  if (isSliceProxy(bytes)) {
+    return (bytes as SliceProxy<number>).__meta__.length
+  }
+  return bytes.length
+}
+
+function byteAt(bytes: ByteData, index: number): number {
+  if (bytes instanceof Uint8Array || Array.isArray(bytes)) {
+    return bytes[index] ?? 0
+  }
+  const meta = (bytes as SliceProxy<number>).__meta__
+  return meta.backing[meta.offset + index] ?? 0
+}
+
 /**
  * bytesToArray converts any Bytes representation to a number array.
  */
 export function bytesToArray(bytes: Bytes | null): number[] {
+  bytes = bytesValue(bytes) as Bytes | null
   if (bytes === null) return []
 
   if (bytes instanceof Uint8Array) {
@@ -497,15 +805,34 @@ export function bytesToArray(bytes: Bytes | null): number[] {
  * bytesToUint8Array converts any Bytes representation to a Uint8Array.
  */
 export function bytesToUint8Array(bytes: Bytes | null): Uint8Array {
+  bytes = bytesValue(bytes) as Bytes | null
   if (bytes === null) return new Uint8Array(0)
 
   if (bytes instanceof Uint8Array) {
+    if ((bytes as Uint8Array & { __meta__?: unknown }).__meta__ !== undefined) {
+      return bytes.subarray(0)
+    }
     return bytes
   }
 
   return new Uint8Array(bytesToArray(bytes))
 }
 
+function bytesValue(value: unknown): unknown {
+  if (isVarRef(value)) {
+    return bytesValue(value.value)
+  }
+  if (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { __goType?: unknown }).__goType === 'string' &&
+    '__goValue' in value
+  ) {
+    return bytesValue((value as { __goValue: unknown }).__goValue)
+  }
+  return value
+}
+
 /**
  * bytesIndexOf finds the first occurrence of subslice in bytes.
  * Returns -1 if not found.