goscript 0.1.0 → 0.1.1

package/gs/path/filepath/path.ts

@@ -1,6 +1,21 @@
 // Package filepath implements utility routines for manipulating filename paths
 // in a way compatible with the target operating system-defined file paths.
 import * as $ from '@goscript/builtin/index.js'
+import { getHostRuntime } from '@goscript/builtin/hostio.js'
+
+type JoinElement = string | $.Slice<string>
+
+function normalizeJoinElements(elem: JoinElement[]): string[] {
+  if (elem.length === 1 && typeof elem[0] !== 'string') {
+    const slice = elem[0]
+    const parts: string[] = []
+    for (let i = 0; i < $.len(slice); i++) {
+      parts.push(slice![i])
+    }
+    return parts
+  }
+  return elem as string[]
+}
 
 // Path separator constants
 export const Separator = $.stringToRune('/')
@@ -123,15 +138,16 @@ export function Clean(path: string): string {
 // are ignored. The result is Cleaned. However, if the argument
 // list is empty or all its elements are empty, Join returns
 // an empty string.
-export function Join(...elem: string[]): string {
-  if (elem.length === 0) {
+export function Join(...elem: JoinElement[]): string {
+  const partsArg = normalizeJoinElements(elem)
+  if (partsArg.length === 0) {
     return ''
   }
 
   // Filter out empty elements but handle absolute paths
   const parts: string[] = []
 
-  for (const e of elem) {
+  for (const e of partsArg) {
     if (e === '') {
       continue
     }
@@ -307,8 +323,7 @@ export function Glob(_pattern: string): [string[], $.GoError] {
 export type WalkFunc = (path: string, info: any, err: $.GoError) => $.GoError
 
 export function Walk(root: string, walkFn: WalkFunc): $.GoError {
-  // No filesystem support, just call the function with the root
-  return walkFn(root, null, $.newError('filesystem not supported'))
+  return walkHost(root, walkFn)
 }
 
 export function WalkDir(_root: string, _walkFn: any): $.GoError {
@@ -320,3 +335,142 @@ export function WalkDir(_root: string, _walkFn: any): $.GoError {
 export function Localize(path: string): [string, $.GoError] {
   return [path, null]
 }
+
+type HostStat = {
+  isDirectory?: boolean | (() => boolean)
+  mode?: number
+  mtimeMs?: number
+  size?: number
+}
+
+type HostEntry = {
+  name: string
+  isDir: boolean
+}
+
+function hostError(err: unknown): $.GoError {
+  const message =
+    err instanceof Error ? err.message
+    : typeof err === 'string' ? err
+    : String(err)
+  return { Error: () => message }
+}
+
+function statIsDir(stat: HostStat): boolean {
+  if (typeof stat.isDirectory === 'function') {
+    return stat.isDirectory()
+  }
+  return !!stat.isDirectory
+}
+
+function fileInfo(path: string, stat: HostStat): any {
+  return {
+    IsDir: () => statIsDir(stat),
+    ModTime: () => null,
+    Mode: () => (stat.mode ?? 0) + (statIsDir(stat) ? 2147483648 : 0),
+    Name: () => Base(path),
+    Size: () => stat.size ?? 0,
+    Sys: () => stat,
+  }
+}
+
+function statPath(path: string): [HostStat | null, $.GoError] {
+  const runtime = getHostRuntime()
+  if (runtime.deno?.statSync) {
+    try {
+      return [runtime.deno.statSync(path), null]
+    } catch (err) {
+      return [null, hostError(err)]
+    }
+  }
+
+  const nodeFS = runtime.nodeFS
+  if (nodeFS?.statSync) {
+    try {
+      return [nodeFS.statSync(path), null]
+    } catch (err) {
+      return [null, hostError(err)]
+    }
+  }
+
+  return [null, $.newError('filesystem not supported')]
+}
+
+function readDir(path: string): [HostEntry[] | null, $.GoError] {
+  const runtime = getHostRuntime()
+  if (runtime.deno?.readDirSync) {
+    try {
+      const entries: HostEntry[] = []
+      for (const entry of runtime.deno.readDirSync(path)) {
+        entries.push({ name: entry.name, isDir: !!entry.isDirectory })
+      }
+      entries.sort((a, b) => a.name.localeCompare(b.name))
+      return [entries, null]
+    } catch (err) {
+      return [null, hostError(err)]
+    }
+  }
+
+  const nodeFS = runtime.nodeFS
+  if (nodeFS?.readdirSync) {
+    try {
+      const entries = nodeFS
+        .readdirSync(path, { withFileTypes: true })
+        .map((entry: any) => ({
+          name: String(entry.name),
+          isDir:
+            typeof entry.isDirectory === 'function' ?
+              entry.isDirectory()
+            : false,
+        }))
+      entries.sort((a, b) => a.name.localeCompare(b.name))
+      return [entries, null]
+    } catch (err) {
+      return [null, hostError(err)]
+    }
+  }
+
+  return [null, $.newError('filesystem not supported')]
+}
+
+function walkHost(path: string, walkFn: WalkFunc): $.GoError {
+  const [stat, statErr] = statPath(path)
+  if (statErr !== null) {
+    return walkFn(path, null, statErr)
+  }
+
+  const visitErr = walkFn(path, fileInfo(path, stat!), null)
+  if (visitErr === SkipAll) {
+    return null
+  }
+  if (visitErr !== null) {
+    if (visitErr === SkipDir && statIsDir(stat!)) {
+      return null
+    }
+    return visitErr
+  }
+  if (!statIsDir(stat!)) {
+    return null
+  }
+
+  const [entries, readErr] = readDir(path)
+  if (readErr !== null) {
+    return walkFn(path, fileInfo(path, stat!), readErr)
+  }
+  for (const entry of entries!) {
+    const err = walkHost(Join(path, entry.name), walkFn)
+    if (err === SkipDir) {
+      if (entry.isDir) {
+        continue
+      }
+      return err
+    }
+    if (err === SkipAll) {
+      return null
+    }
+    if (err !== null) {
+      return err
+    }
+  }
+  return null
+}

package/gs/path/path.ts

@@ -1,5 +1,19 @@
 import * as $ from '@goscript/builtin/index.js'
 
+type JoinElement = string | $.Slice<string>
+
+function normalizeJoinElements(elem: JoinElement[]): string[] {
+  if (elem.length === 1 && typeof elem[0] !== 'string') {
+    const slice = elem[0]
+    const parts: string[] = []
+    for (let i = 0; i < $.len(slice); i++) {
+      parts.push(slice![i])
+    }
+    return parts
+  }
+  return elem as string[]
+}
+
 class lazybuf {
   public get s(): string {
     return this._fields.s.value
@@ -245,10 +259,11 @@ export function Split(path: string): [string, string] {
 // The result is Cleaned. However, if the argument list is
 // empty or all its elements are empty, Join returns
 // an empty string.
-export function Join(...elem: string[]): string {
+export function Join(...elem: JoinElement[]): string {
+  const parts = normalizeJoinElements(elem)
   let size = 0
-  for (let _i = 0; _i < $.len(elem); _i++) {
-    const e = elem![_i]
+  for (let _i = 0; _i < $.len(parts); _i++) {
+    const e = parts![_i]
     {
       size += $.len(e)
     }
@@ -257,8 +272,8 @@ export function Join(...elem: string[]): string {
     return ''
   }
   let buf: string[] = []
-  for (let _i = 0; _i < $.len(elem); _i++) {
-    const e = elem![_i]
+  for (let _i = 0; _i < $.len(parts); _i++) {
+    const e = parts![_i]
     {
       if ($.len(buf) > 0 || e != '') {
         if ($.len(buf) > 0) {

package/gs/reflect/index.ts

@@ -2,6 +2,7 @@
 export {
   TypeOf,
   TypeFor,
+  TypeAssert,
   ValueOf,
   Value,
   Kind_String,

package/gs/reflect/map.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { MapIter } from './map.js'
+import { ValueOf } from './type.js'
 
 describe('MapIter', () => {
   it('should iterate over map entries with proper typing', () => {
@@ -29,3 +30,21 @@ describe('MapIter', () => {
     expect(iter.Value().Interface()).toBe(100)
   })
 })
+
+describe('Value.MapKeys', () => {
+  it('returns map keys as reflect values', () => {
+    const map = new Map<string, number>()
+    map.set('alpha', 1)
+    map.set('beta', 2)
+
+    const keys = ValueOf(map).MapKeys()
+
+    expect(keys?.map((key) => key.String()).sort()).toEqual(['alpha', 'beta'])
+  })
+
+  it('returns an empty slice for empty maps', () => {
+    const emptyMap = new Map<string, number>()
+
+    expect(ValueOf(emptyMap).MapKeys()).toEqual([])
+  })
+})

package/gs/reflect/map.ts

@@ -78,6 +78,10 @@ class MapType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error('reflect: Len of non-array type map')
+  }
+
   public Bits(): number {
     throw new Error('reflect: Bits of non-sized type map')
   }

package/gs/reflect/type.ts

@@ -173,6 +173,20 @@ export const String: Kind = 24
 export const Struct: Kind = 25
 export const UnsafePointer: Kind = 26
 
+const pointerAddressStride = 0x100000000
+const pointerAddresses = new WeakMap<object, number>()
+let nextPointerAddress = 1
+
+function pointerAddress(value: object): number {
+  let address = pointerAddresses.get(value)
+  if (address === undefined) {
+    address = nextPointerAddress * pointerAddressStride
+    nextPointerAddress++
+    pointerAddresses.set(value, address)
+  }
+  return address
+}
+
 // Type is the representation of a Go type.
 export interface Type {
   // String returns a string representation of the type.
@@ -226,6 +240,10 @@ export interface Type {
   // NumMethod returns the number of methods in the type's method set
   NumMethod(): number
 
+  // Len returns an array type's length.
+  // Panics if the type's Kind is not Array.
+  Len(): number
+
   // Bits returns the size of the type in bits
   // Panics if the type's Kind is not a sized type.
   Bits(): number
@@ -272,6 +290,9 @@ class InvalidTypeClass implements Type {
   NumMethod(): number {
     return 0
   }
+  Len(): number {
+    throw new Error('reflect: Len of invalid type')
+  }
   Bits(): number {
     throw new Error('reflect: Bits of invalid type')
   }
@@ -508,6 +529,45 @@ export class Value {
     return this._value
   }
 
+  public Pointer(): number {
+    const kind = this.Kind()
+    if (
+      kind !== Chan &&
+      kind !== Func &&
+      kind !== Map &&
+      kind !== Ptr &&
+      kind !== Slice &&
+      kind !== UnsafePointer
+    ) {
+      throw new ValueError({ Kind: kind, Method: 'Pointer' })
+    }
+    if (this._value === null || this._value === undefined) {
+      return 0
+    }
+    if ($.isVarRef(this._value)) {
+      const address = this._value.__goAddress?.()
+      if (address !== undefined) {
+        return address
+      }
+      return pointerAddress(this._value)
+    }
+    if (kind === Slice) {
+      const slice = this._value as $.Slice<unknown> | Uint8Array
+      try {
+        if ($.len(slice) === 0) {
+          return 0
+        }
+        return $.indexAddress(slice, 0)
+      } catch {
+        return 0
+      }
+    }
+    if (typeof this._value === 'object' || typeof this._value === 'function') {
+      return pointerAddress(this._value)
+    }
+    return 0
+  }
+
   public pointer(): unknown {
     return this._value
   }
@@ -607,9 +667,35 @@ export class Value {
     return new Value(null, new BasicType(Invalid, 'invalid'))
   }
 
-  public Complex(): number | { real: number; imag: number } | null {
-    // Placeholder for complex number support
-    return this._value as number | { real: number; imag: number } | null
+  public MapKeys(): $.Slice<Value> {
+    if (this.Kind() !== Map) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'MapKeys' })
+    }
+    if (this._value === null || this._value === undefined) {
+      return $.makeSlice<Value>(0)
+    }
+    if (!(this._value instanceof globalThis.Map)) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'MapKeys' })
+    }
+    const keyType = this.Type().Key()
+    const keys: Value[] = []
+    for (const key of this._value.keys()) {
+      keys.push(new Value(key as ReflectValue, keyType))
+    }
+    return $.arrayToSlice(keys)
+  }
+
+  public Complex(): number | $.Complex | null {
+    const k = this.Kind()
+    if (k !== Complex64 && k !== Complex128) {
+      throw new Error(
+        'reflect: call of reflect.Value.Complex on ' +
+          Kind_String(k) +
+          ' Value',
+      )
+    }
+    const value = this._parentVarRef ? this._parentVarRef.value : this._value
+    return value as number | $.Complex | null
   }
 
   // Send sends a value to a channel
@@ -755,6 +841,28 @@ export class Value {
     }
   }
 
+  // SetComplex sets v's underlying value to x
+  public SetComplex(x: number | $.Complex): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetComplex on unaddressable value',
+      )
+    }
+    const k = this.Kind()
+    if (k !== Complex64 && k !== Complex128) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetComplex on ' + k + ' Value',
+      )
+    }
+    this._value = x
+    if (this._parentVarRef) {
+      this._parentVarRef.value = x
+    }
+    if (this._parentStruct && this._fieldName) {
+      this._parentStruct[this._fieldName] = x
+    }
+  }
+
   // SetBytes sets v's underlying value to x
   public SetBytes(x: $.Slice<number>): void {
     if (!this.CanSet()) {
@@ -1056,6 +1164,14 @@ export class BasicType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error(
+      'reflect: call of reflect.Type.Len on ' +
+        Kind_String(this._kind) +
+        ' Type',
+    )
+  }
+
   public Bits(): number {
     const k = this._kind
     switch (k) {
@@ -1075,6 +1191,10 @@ export class BasicType implements Type {
       case Uint64:
       case Float64:
         return 64
+      case Complex64:
+        return 64
+      case Complex128:
+        return 128
       case Int:
       case Uint:
       case Uintptr:
@@ -1154,6 +1274,10 @@ class SliceType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on slice Type')
+  }
+
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on slice Type')
   }
@@ -1319,6 +1443,10 @@ class PointerType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on pointer Type')
+  }
+
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on pointer Type')
   }
@@ -1395,6 +1523,10 @@ class FunctionType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on func Type')
+  }
+
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on func Type')
   }
@@ -1474,6 +1606,10 @@ class MapType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on map Type')
+  }
+
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on map Type')
   }
@@ -1632,6 +1768,10 @@ class StructType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on struct Type')
+  }
+
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on struct Type')
   }
@@ -1651,6 +1791,10 @@ class StructType implements Type {
           return new BasicType(Bool, 'bool', 1)
         case 'float64':
           return new BasicType(Float64, ti, 8)
+        case 'complex64':
+          return new BasicType(Complex64, ti, 8)
+        case 'complex128':
+          return new BasicType(Complex128, ti, 16)
         case 'uint':
         case 'uint32':
         case 'uint64':
@@ -1677,6 +1821,10 @@ class StructType implements Type {
               return new BasicType(Bool, 'bool', 1)
             case 'float64':
               return new BasicType(Float64, 'float64', 8)
+            case 'complex64':
+              return new BasicType(Complex64, 'complex64', 8)
+            case 'complex128':
+              return new BasicType(Complex128, 'complex128', 16)
             default:
               return new BasicType(Invalid, name, 8)
           }
@@ -1794,6 +1942,10 @@ class ChannelType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on chan Type')
+  }
+
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on chan Type')
   }
@@ -1827,10 +1979,7 @@ class InterfaceType implements Type {
   }
 
   public PkgPath?(): string {
-    if (
-      this._name === 'interface{}' ||
-      this._name.startsWith('interface {')
-    ) {
+    if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
       return ''
     }
     const dotIndex = this._name.lastIndexOf('.')
@@ -1841,10 +1990,7 @@ class InterfaceType implements Type {
   }
 
   public Name(): string {
-    if (
-      this._name === 'interface{}' ||
-      this._name.startsWith('interface {')
-    ) {
+    if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
       return this._name
     }
     const dotIndex = this._name.lastIndexOf('.')
@@ -1892,6 +2038,10 @@ class InterfaceType implements Type {
     return 0
   }
 
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on interface Type')
+  }
+
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on interface Type')
   }
@@ -2003,6 +2153,15 @@ function getTypeOf(value: ReflectValue): Type {
         return new PointerType(elemType)
       }
 
+      if (
+        'real' in value &&
+        'imag' in value &&
+        typeof (value as $.Complex).real === 'number' &&
+        typeof (value as $.Complex).imag === 'number'
+      ) {
+        return new BasicType(Complex128, 'complex128', 16)
+      }
+
       // Check for arrays
       if (globalThis.Array.isArray(value)) {
         if (value.length === 0) {
@@ -2101,7 +2260,7 @@ function getTypeOf(value: ReflectValue): Type {
                 // Check if fieldInfo is a StructFieldInfo with type and tag
                 if (isStructFieldInfo(fieldInfo)) {
                   return {
-                    name,
+                    name: fieldInfo.name ?? name,
                     type: StructType.createTypeFromFieldInfo(fieldInfo.type),
                     tag: fieldInfo.tag,
                   }
@@ -2141,6 +2300,17 @@ export function ValueOf(i: ReflectValue): Value {
   return new Value(i, getTypeOf(i))
 }
 
+export function TypeAssert(
+  typeArgs: $.GenericTypeArgs | undefined,
+  v: Value,
+): [any, boolean] {
+  const descriptor = typeArgs?.T
+  if (!descriptor?.type) {
+    return [v.Interface(), true]
+  }
+  return $.typeAssertTuple<any>(v.Interface(), descriptor.type)
+}
+
 export function ArrayOf(length: number, elem: Type): Type {
   return new ArrayType(elem, length)
 }
@@ -2196,12 +2366,16 @@ function typeFromTypeInfo(info: $.TypeInfo | string): Type {
   switch (info.kind) {
     case $.TypeKind.Array:
       return new ArrayType(
-        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        typeFromTypeInfo(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        ),
         info.length,
       )
     case $.TypeKind.Channel:
       return new ChannelType(
-        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        typeFromTypeInfo(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        ),
         chanDirFromTypeInfo(info.direction),
       )
     case $.TypeKind.Function:
@@ -2210,12 +2384,18 @@ function typeFromTypeInfo(info: $.TypeInfo | string): Type {
       return interfaceTypeFromInfo(info)
     case $.TypeKind.Map:
       return new MapType(
-        typeFromTypeInfo(info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
-        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        typeFromTypeInfo(
+          info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        ),
+        typeFromTypeInfo(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        ),
       )
     case $.TypeKind.Pointer:
       return new PointerType(
-        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+        typeFromTypeInfo(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        ),
       )
     default:
       return StructType.createTypeFromFieldInfo(info)

package/gs/runtime/debug/index.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { PrintStack, Stack } from './index.js'
+
+describe('runtime/debug override', () => {
+  it('returns a stack trace as bytes', () => {
+    const stack = Stack()
+
+    expect(stack).toBeInstanceOf(Uint8Array)
+    expect(new TextDecoder().decode(stack)).toContain('Error')
+  })
+
+  it('prints the current stack trace', () => {
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    try {
+      PrintStack()
+      expect(consoleError).toHaveBeenCalledTimes(1)
+      expect(consoleError.mock.calls[0][0]).toContain('Error')
+    } finally {
+      consoleError.mockRestore()
+    }
+  })
+})

package/gs/runtime/debug/index.ts

@@ -0,0 +1,8 @@
+export function Stack(): Uint8Array {
+  const stack = new Error().stack ?? 'stack trace unavailable'
+  return new TextEncoder().encode(stack)
+}
+
+export function PrintStack(): void {
+  console.error(new TextDecoder().decode(Stack()))
+}