goscript 0.1.0 → 0.1.1

package/gs/builtin/slice.ts

@@ -1,3 +1,5 @@
+import { varRef, type VarRef } from './varRef.js'
+
 /**
  * GoSliceObject contains metadata for complex slice views
  */
@@ -8,6 +10,10 @@ interface GoSliceObject<T> {
   capacity: number // Capacity of the slice
 }
 
+const addressStride = 0x100000000
+let nextAddressBase = 1
+const addressBases = new WeakMap<object, number>()
+
 /**
  * SliceProxy is a proxy object for complex slices
  */
@@ -104,6 +110,44 @@ export function asArray<T>(slice: Slice<T>): T[] {
   return []
 }
 
+export function sliceToArray<T>(
+  slice: Slice<T> | Uint8Array,
+  length: number,
+  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}`,
+    )
+  }
+  if (typeHint === 'byte') {
+    return new Uint8Array(asArray(slice as Slice<T>).slice(0, length) as number[])
+  }
+  return asArray(slice as Slice<T>).slice(0, length)
+}
+
+export function sliceToArrayPointer<T>(
+  slice: Slice<T> | Uint8Array,
+  length: number,
+  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}`,
+    )
+  }
+  if (typeHint === 'byte') {
+    if (slice instanceof Uint8Array) {
+      return varRef(goSlice(slice, 0, length) as unknown as Uint8Array)
+    }
+    return varRef(goSlice(slice as Slice<T>, 0, length) as unknown as Uint8Array)
+  }
+  if (slice instanceof Uint8Array) {
+    return varRef(goSlice(slice, 0, length) as unknown as T[])
+  }
+  return varRef(goSlice(slice, 0, length) as T[])
+}
+
 /**
  * isComplexSlice checks if a slice is a complex slice (has __meta__ property)
  */
@@ -117,6 +161,13 @@ function isComplexSlice<T>(slice: Slice<T>): slice is SliceProxy<T> {
   )
 }
 
+function normalizeSliceIndex(value: number | undefined): number | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+  return Number(value)
+}
+
 /**
  * isSliceProxy checks if a slice is a SliceProxy (has __meta__ property)
  * This is an alias for isComplexSlice for better type hinting
@@ -135,6 +186,7 @@ export const makeSlice = <T>(
   length: number,
   capacity?: number,
   typeHint?: string,
+  zeroFactory?: () => T,
 ): Slice<T> => {
   if (typeHint === 'byte') {
     const actualCapacity = capacity === undefined ? length : capacity
@@ -176,25 +228,26 @@ export const makeSlice = <T>(
     )
   }
 
-  let zeroVal: any
-  switch (typeHint) {
-    case 'number':
-      zeroVal = 0
-      break
-    case 'boolean':
-      zeroVal = false
-      break
-    case 'string':
-      zeroVal = ''
-      break
-    default:
-      zeroVal = null // Default for objects, complex types, or unspecified
+  const zeroValue = (): T => {
+    if (zeroFactory !== undefined) {
+      return zeroFactory()
+    }
+    switch (typeHint) {
+      case 'number':
+        return 0 as T
+      case 'boolean':
+        return false as T
+      case 'string':
+        return '' as T
+      default:
+        return null as T // Default for objects, complex types, or unspecified
+    }
   }
 
   const backingArr = new Array<T>(actualCapacity)
   // Initialize the relevant part of the backing array
   for (let i = 0; i < length; i++) {
-    backingArr[i] = zeroVal
+    backingArr[i] = zeroValue()
   }
   // The rest of backingArr (from length to actualCapacity-1) remains uninitialized (undefined),
   // representing available capacity.
@@ -208,7 +261,7 @@ export const makeSlice = <T>(
   // Its elements up to 'length' should reflect the initialized part of the slice.
   const proxyTargetArray = new Array<T>(length)
   for (let i = 0; i < length; i++) {
-    proxyTargetArray[i] = backingArr[i] // Or simply zeroVal
+    proxyTargetArray[i] = backingArr[i]
   }
 
   const proxy = proxyTargetArray as SliceProxy<T>
@@ -296,6 +349,10 @@ export function goSlice<T>( // T can be number for Uint8Array case
   high?: number,
   max?: number,
 ): Slice<T> {
+  low = normalizeSliceIndex(low)
+  high = normalizeSliceIndex(high)
+  max = normalizeSliceIndex(max)
+
   const handler = {
     get(target: any, prop: string | symbol): any {
       if (typeof prop === 'string' && /^\d+$/.test(prop)) {
@@ -339,6 +396,7 @@ export function goSlice<T>( // T can be number for Uint8Array case
         const index = Number(prop)
         if (index >= 0 && index < target.__meta__.length) {
           target.__meta__.backing[target.__meta__.offset + index] = value
+          target[index] = value
           return true
         }
         if (
@@ -346,6 +404,7 @@ export function goSlice<T>( // T can be number for Uint8Array case
           target.__meta__.length < target.__meta__.capacity
         ) {
           target.__meta__.backing[target.__meta__.offset + index] = value
+          target[index] = value
           target.__meta__.length++
           return true
         }
@@ -372,7 +431,7 @@ export function goSlice<T>( // T can be number for Uint8Array case
       )
     }
 
-    const subArrayView = s.subarray(actualLow, actualHigh) // This is Uint8Array
+    const newLength = actualHigh - actualLow
 
     if (max !== undefined) {
       if (max < actualHigh || max > s.length) {
@@ -382,35 +441,36 @@ export function goSlice<T>( // T can be number for Uint8Array case
         )
       }
 
-      const newLength = subArrayView.length // actualHigh - actualLow
       const newCap = max - actualLow // Capacity of the new slice view
 
       if (newCap !== newLength) {
-        // Capacity is different from length, so return SliceProxy<number>
-        // The original s was Uint8Array, so T is effectively 'number' for this path.
-        const backingNumbers = Array.from(subArrayView) // Convert Uint8Array data to number[]
-
-        const proxyTarget = {
-          __meta__: {
-            backing: backingNumbers, // number[]
-            offset: 0, // Offset is 0 because backingNumbers is a direct copy
-            length: newLength,
-            capacity: newCap,
-          },
+        const proxyTarget = new Array<number>(newLength) as SliceProxy<number>
+        proxyTarget.__meta__ = {
+          backing: s as unknown as number[],
+          offset: actualLow,
+          length: newLength,
+          capacity: newCap,
         }
-        // Explicitly cast to Slice<T> after ensuring T is number for this branch.
-        return new Proxy(
-          proxyTarget,
-          handler,
-        ) as unknown as SliceProxy<number> as Slice<T>
+        return new Proxy(proxyTarget, handler) as unknown as Slice<T>
       } else {
         // newCap === newLength, standard Uint8Array is fine.
-        return subArrayView as Slice<T> // T is number
+        return s.subarray(actualLow, actualHigh) as Slice<T> // T is number
       }
-    } else {
-      // max is not defined, return the Uint8Array subarray view directly.
-      return subArrayView as Slice<T> // T is number
     }
+
+    if (actualHigh !== s.length) {
+      const proxyTarget = new Array<number>(newLength) as SliceProxy<number>
+      proxyTarget.__meta__ = {
+        backing: s as unknown as number[],
+        offset: actualLow,
+        length: newLength,
+        capacity: s.length - actualLow,
+      }
+      return new Proxy(proxyTarget, handler) as unknown as Slice<T>
+    }
+
+    // max is not defined and length equals capacity, return the Uint8Array view directly.
+    return s.subarray(actualLow, actualHigh) as Slice<T> // T is number
   }
 
   // Handle nil slices - in Go, slicing a nil slice with valid bounds returns nil
@@ -645,6 +705,7 @@ export const len = <T = unknown, V = unknown>(
     | Map<T, V>
     | Set<T>
     | Uint8Array
+    | { len(): number }
     | null
     | undefined,
 ): number => {
@@ -664,8 +725,12 @@ export const len = <T = unknown, V = unknown>(
     return obj.length
   }
 
-  if (isComplexSlice(obj)) {
-    return obj.__meta__.length
+  if (typeof (obj as any).len === 'function') {
+    return (obj as { len(): number }).len()
+  }
+
+  if (isComplexSlice(obj as any)) {
+    return (obj as SliceProxy<T>).__meta__.length
   }
 
   if (Array.isArray(obj)) {
@@ -719,18 +784,14 @@ export function append<T>(
   // 1. Flatten all elements from the varargs `...elements` into `varargsElements`.
   // Determine if the result should be a Uint8Array.
   const inputIsUint8Array = slice instanceof Uint8Array
-  const appendingUint8Array = elements.some((el) => el instanceof Uint8Array)
-  const produceUint8Array =
-    inputIsUint8Array ||
-    appendingUint8Array ||
-    (slice === null && appendingUint8Array)
+  const produceUint8Array = inputIsUint8Array
 
   // If producing Uint8Array, all elements must be numbers and potentially flattened from other Uint8Arrays/number slices.
   if (produceUint8Array) {
     let combinedBytes: number[] = []
     // Add bytes from the original slice if it exists and is numeric.
     if (inputIsUint8Array) {
-      combinedBytes.push(...Array.from(slice as Uint8Array))
+      appendBytes(combinedBytes, slice as Uint8Array)
     } else if (slice !== null && slice !== undefined) {
       // Original was Slice<number> or number[]
       const sliceLen = len(slice)
@@ -748,7 +809,7 @@ export function append<T>(
     // For Uint8Array, elements are always flattened if they are slices/Uint8Arrays.
     for (const item of elements) {
       if (item instanceof Uint8Array) {
-        combinedBytes.push(...Array.from(item))
+        appendBytes(combinedBytes, item)
       } else if (isComplexSlice(item) || Array.isArray(item)) {
         const itemLen = len(item as Slice<any>)
         for (let i = 0; i < itemLen; i++) {
@@ -856,6 +917,12 @@ export function append<T>(
   return wrapSliceProxy(resultProxy) as any
 }
 
+function appendBytes(dst: number[], src: Uint8Array): void {
+  for (let i = 0; i < src.length; i++) {
+    dst.push(src[i])
+  }
+}
+
 /**
  * Copies elements from src to dst.
  * @param dst The destination slice.
@@ -1072,6 +1139,117 @@ export function index<T>(
   throw new Error('runtime error: index on unsupported type')
 }
 
+/**
+ * indexRef returns an addressable reference to a slice or array element.
+ */
+export function indexRef<T>(
+  collection: Slice<T> | T[] | Uint8Array,
+  index: number,
+): VarRef<T> {
+  if (collection === null || collection === undefined) {
+    throw new Error('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}`,
+      )
+    }
+    return {
+      get value() {
+        return collection[index] as T
+      },
+      set value(value: T) {
+        collection[index] = value as number
+      },
+      __isVarRef: true,
+      __goAddress: () => indexAddress(collection, index),
+    }
+  }
+  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}`,
+      )
+    }
+    const backingIndex = collection.__meta__.offset + index
+    return {
+      get value() {
+        return collection.__meta__.backing[backingIndex]
+      },
+      set value(value: T) {
+        collection[index] = value
+      },
+      __isVarRef: true,
+      __goAddress: () => indexAddress(collection, index),
+    }
+  }
+  if (Array.isArray(collection)) {
+    if (index < 0 || index >= collection.length) {
+      throw new Error(
+        `runtime error: index out of range [${index}] with length ${collection.length}`,
+      )
+    }
+    return {
+      get value() {
+        return collection[index]
+      },
+      set value(value: T) {
+        collection[index] = value
+      },
+      __isVarRef: true,
+      __goAddress: () => indexAddress(collection, index),
+    }
+  }
+  throw new Error('runtime error: index on unsupported type')
+}
+
+/**
+ * indexAddress returns a stable synthetic address for an addressable slice or
+ * array element.
+ */
+export function indexAddress<T>(
+  collection: Slice<T> | T[] | Uint8Array,
+  index: number,
+): number {
+  if (collection === null || collection === undefined) {
+    throw new Error('runtime error: index on nil or undefined collection')
+  }
+
+  let backing: object
+  let backingIndex: number
+  let length: number
+  if (collection instanceof Uint8Array) {
+    backing = collection.buffer
+    backingIndex = collection.byteOffset + index
+    length = collection.length
+  } else if (isComplexSlice(collection)) {
+    backing = collection.__meta__.backing
+    backingIndex = collection.__meta__.offset + index
+    length = collection.__meta__.length
+  } else if (Array.isArray(collection)) {
+    backing = collection
+    backingIndex = index
+    length = collection.length
+  } else {
+    throw new Error('runtime error: index on unsupported type')
+  }
+
+  if (index < 0 || index >= length) {
+    throw new Error(
+      `runtime error: index out of range [${index}] with length ${length}`,
+    )
+  }
+
+  let base = addressBases.get(backing)
+  if (base === undefined) {
+    base = nextAddressBase * addressStride
+    nextAddressBase++
+    addressBases.set(backing, base)
+  }
+  return base + backingIndex
+}
+
 /**
  * Converts a string to an array of Unicode code points (runes).
  * @param str The input string.
@@ -1081,6 +1259,22 @@ export const stringToRunes = (str: string): number[] => {
   return Array.from(str).map((c) => c.codePointAt(0) || 0)
 }
 
+/**
+ * Returns Go range pairs for a string: UTF-8 byte offset and rune value.
+ * @param str The input string.
+ * @returns Index/rune pairs matching Go's `for i, r := range str`.
+ */
+export const rangeString = (str: string): Array<[number, number]> => {
+  const encoder = new TextEncoder()
+  const pairs: Array<[number, number]> = []
+  let offset = 0
+  for (const char of str) {
+    pairs.push([offset, char.codePointAt(0) || 0])
+    offset += encoder.encode(char).length
+  }
+  return pairs
+}
+
 /**
  * Converts a single-character string to its Unicode code point (rune).
  * Used for readable rune constants like $.stringToRune('/') instead of 47.
@@ -1231,9 +1425,7 @@ export const bytesToString = (
   if (bytes === null) return ''
   // If it's already a string, just return it
   if (typeof bytes === 'string') return bytes
-  if (bytes instanceof Uint8Array) {
-    return new TextDecoder().decode(bytes)
-  }
+  if (bytes instanceof Uint8Array) return decodeGoStringBytes(bytes)
   // Ensure we get a plain number[] for Uint8Array.from
   let byteArray: number[]
   if (isComplexSlice(bytes)) {
@@ -1246,7 +1438,24 @@ export const bytesToString = (
     // For simple T[] slices
     byteArray = bytes
   }
-  return new TextDecoder().decode(Uint8Array.from(byteArray))
+  return decodeGoStringBytes(Uint8Array.from(byteArray))
+}
+
+function decodeGoStringBytes(bytes: Uint8Array): string {
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes)
+  } catch {
+    return bytesToBinaryString(bytes)
+  }
+}
+
+function bytesToBinaryString(bytes: Uint8Array): string {
+  const chunkSize = 0x8000
+  let out = ''
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    out += String.fromCharCode(...bytes.subarray(i, i + chunkSize))
+  }
+  return out
 }
 
 /**