goscript 0.1.0 → 0.1.2

package/gs/path/filepath/path.test.ts

@@ -1,4 +1,7 @@
 import { describe, it, expect } from 'vitest'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import {
   Base,
   Dir,
@@ -16,6 +19,9 @@ import {
   Abs,
   Rel,
   EvalSymlinks,
+  Walk,
+  WalkDir,
+  SkipDir,
   Separator,
   ListSeparator,
 } from './path.js'
@@ -201,6 +207,80 @@ describe('path/filepath - Path manipulation functions', () => {
     })
   })
 
+  describe('Walk', () => {
+    it('should visit host filesystem paths in lexical order', async () => {
+      const root = mkdtempSync(join(tmpdir(), 'goscript-filepath-walk-'))
+      try {
+        mkdirSync(join(root, 'a', 'b'), { recursive: true })
+        writeFileSync(join(root, 'a', 'b', 'file.txt'), 'ok')
+
+        const visited: string[] = []
+        const err = await Walk(root, (path) => {
+          visited.push(path.slice(root.length).replace(/^\/?/, '') || '.')
+          return null
+        })
+
+        expect(err).toBeNull()
+        expect(visited).toEqual(['.', 'a', 'a/b', 'a/b/file.txt'])
+      } finally {
+        rmSync(root, { force: true, recursive: true })
+      }
+    })
+  })
+
+  describe('WalkDir', () => {
+    it('should visit host filesystem dir entries in lexical order', async () => {
+      const root = mkdtempSync(join(tmpdir(), 'goscript-filepath-walkdir-'))
+      try {
+        mkdirSync(join(root, 'b'), { recursive: true })
+        mkdirSync(join(root, 'a'), { recursive: true })
+        writeFileSync(join(root, 'a', 'skipped.txt'), 'skip')
+        writeFileSync(join(root, 'b', 'file.txt'), 'ok')
+
+        const visited: string[] = []
+        const err = await WalkDir(root, (path, d, walkErr) => {
+          expect(walkErr).toBeNull()
+          visited.push(
+            `${path.slice(root.length).replace(/^\/?/, '') || '.'}:${d.Name()}:${d.IsDir()}`,
+          )
+          if (d.Name() === 'a') {
+            return SkipDir
+          }
+          return null
+        })
+
+        expect(err).toBeNull()
+        expect(visited).toEqual([
+          `.:${root.split('/').pop()}:true`,
+          'a:a:true',
+          'b:b:true',
+          'b/file.txt:file.txt:false',
+        ])
+      } finally {
+        rmSync(root, { force: true, recursive: true })
+      }
+    })
+
+    it('should await async host filesystem dir callbacks', async () => {
+      const root = mkdtempSync(join(tmpdir(), 'goscript-filepath-walkdir-'))
+      try {
+        writeFileSync(join(root, 'file.txt'), 'ok')
+
+        const visited: string[] = []
+        const err = await WalkDir(root, async (path) => {
+          await Promise.resolve()
+          visited.push(path.slice(root.length).replace(/^\/?/, '') || '.')
+          return null
+        })
+
+        expect(err).toBeNull()
+        expect(visited).toEqual(['.', 'file.txt'])
+      } finally {
+        rmSync(root, { force: true, recursive: true })
+      }
+    })
+  })
+
   describe('Constants', () => {
     it('should have correct separator constants', () => {
       expect(Separator).toBe(47)

package/gs/path/filepath/path.ts

@@ -1,6 +1,23 @@
 // 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'
+import type { DirEntry } from '@goscript/io/fs/fs.js'
+import { FileInfoToDirEntry } from '@goscript/io/fs/readdir.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 +140,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
     }
@@ -304,19 +322,234 @@ export function Glob(_pattern: string): [string[], $.GoError] {
 // prefix; that is, if Walk is called with "dir" and finds a file "a"
 // in that directory, the walk function will be called with argument
 // "dir/a". The info argument is the fs.FileInfo for the named path.
-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'))
+export type WalkFunc = (
+  path: string,
+  info: any,
+  err: $.GoError,
+) => $.GoError | Promise<$.GoError>
+
+export async function Walk(root: string, walkFn: WalkFunc): Promise<$.GoError> {
+  return await walkHost(root, walkFn)
 }
 
-export function WalkDir(_root: string, _walkFn: any): $.GoError {
-  // No filesystem support
-  return $.newError('filesystem not supported')
+export type WalkDirFunc = (
+  path: string,
+  d: DirEntry,
+  err: $.GoError,
+) => $.GoError | Promise<$.GoError>
+
+export async function WalkDir(
+  root: string,
+  walkFn: WalkDirFunc,
+): Promise<$.GoError> {
+  return await walkDirHost(root, walkFn)
 }
 
 // Localize is a stub - in Go it's used for Windows path localization
 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 dirEntry(path: string, stat: HostStat): DirEntry {
+  return FileInfoToDirEntry(fileInfo(path, 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')]
+}
+
+async function walkHost(path: string, walkFn: WalkFunc): Promise<$.GoError> {
+  const [stat, statErr] = statPath(path)
+  if (statErr !== null) {
+    return await walkFn(path, null, statErr)
+  }
+
+  const visitErr = await 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 await walkFn(path, fileInfo(path, stat!), readErr)
+  }
+  for (const entry of entries!) {
+    const err = await 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
+}
+
+function normalizeWalkDirErr(d: DirEntry, err: $.GoError): $.GoError {
+  if (err === SkipAll) {
+    return null
+  }
+  if (err === SkipDir && d?.IsDir?.()) {
+    return null
+  }
+  return err
+}
+
+function normalizeRootWalkDirErr(err: $.GoError): $.GoError {
+  if (err === SkipAll || err === SkipDir) {
+    return null
+  }
+  return err
+}
+
+async function walkDirHost(
+  path: string,
+  walkFn: WalkDirFunc,
+): Promise<$.GoError> {
+  const [stat, statErr] = statPath(path)
+  if (statErr !== null) {
+    return normalizeRootWalkDirErr(await walkFn(path, null, statErr))
+  }
+
+  const d = dirEntry(path, stat!)
+  const visitErr = await walkFn(path, d, null)
+  if (visitErr === SkipAll) {
+    return null
+  }
+  if (visitErr === SkipDir && statIsDir(stat!)) {
+    return null
+  }
+  if (visitErr !== null || !statIsDir(stat!)) {
+    return visitErr
+  }
+
+  const [entries, readErr] = readDir(path)
+  if (readErr !== null) {
+    return normalizeWalkDirErr(d, await walkFn(path, d, readErr))
+  }
+
+  for (const entry of entries!) {
+    const err = await walkDirHost(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/field.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  TypeKind,
+  arrayToSlice,
+  asArray,
+  registerStructType,
+} from '../builtin/index.js'
+import { NewAt, TypeOf, ValueOf } from './index.js'
+
+class Person {
+  public Name = 'Ada'
+  public Count = 3
+
+  public String(): string {
+    return this.Name
+  }
+}
+;(Person as any).__typeInfo = { name: 'main.Person' }
+
+describe('reflect struct field access', () => {
+  it('finds struct fields by name and index', () => {
+    registerStructType(
+      'main.Person',
+      new Person(),
+      [{ name: 'String', args: [], returns: [] }],
+      Person,
+      {
+        Name: 'string',
+        Count: { kind: TypeKind.Basic, name: 'int' },
+      },
+    )
+
+    const person = new Person()
+    const typ = TypeOf(person)
+    const [field, ok] = typ.FieldByName('Name')
+
+    expect(ok).toBe(true)
+    expect(field.Name).toBe('Name')
+    expect(field.Index).toEqual([0])
+    expect(typ.FieldByNameFunc((name) => name === 'Count')[0].Name).toBe(
+      'Count',
+    )
+    expect(typ.AssignableTo(typ)).toBe(true)
+    expect(typ.MethodByName('String')[1]).toBe(true)
+    expect(ValueOf(person).FieldByName('Name').String()).toBe('Ada')
+    expect(
+      ValueOf(person)
+        .FieldByIndex(arrayToSlice([1]))
+        .Int(),
+    ).toBe(3)
+    expect(ValueOf(person).FieldByName('Missing').IsValid()).toBe(false)
+
+    const stringMethod = ValueOf(person).MethodByName('String')
+    expect(stringMethod.IsValid()).toBe(true)
+    expect(asArray(stringMethod.Call(arrayToSlice([])))[0].String()).toBe('Ada')
+
+    const nameField = ValueOf(person).FieldByName('Name')
+    const namePtr = NewAt(nameField.Type(), nameField.UnsafeAddr() as any)
+    namePtr.Elem().SetString('Grace')
+    expect(person.Name).toBe('Grace')
+  })
+})

package/gs/reflect/index.ts

@@ -2,6 +2,7 @@
 export {
   TypeOf,
   TypeFor,
+  TypeAssert,
   ValueOf,
   Value,
   Kind_String,
@@ -25,13 +26,17 @@ export {
   Copy,
   Indirect,
   New,
+  NewAt,
   MakeSlice,
   MakeMap,
+  MakeMapWithSize,
   Append,
+  AppendSlice,
   MakeChan,
   Select,
 } from './value.js'
 export { Swapper } from './swapper.js'
+export { MapIter } from './map.js'
 
 // Export new types and constants
 export {
@@ -51,7 +56,6 @@ export type {
   SelectDir,
   SliceHeader,
   StringHeader,
-  MapIter,
 } from './types.js'
 
 // Export kind constants

package/gs/reflect/iter.ts

@@ -11,7 +11,7 @@ export function rangeNum<T extends number | uintptr, N extends number | number>(
 
   // if the iteration value type is define by
   // type T built-in type.
-  return (_yield: ((v: Value) => boolean) | null): void => {
+  return async (_yield: ((v: Value) => iter.YieldResult) | null): Promise<void> => {
     let convert = t!.PkgPath!() != ''
     // cannot use range T(v) because no core type.
 
@@ -24,7 +24,7 @@ export function rangeNum<T extends number | uintptr, N extends number | number>(
       if (convert) {
         tmp = tmp.Convert(t).clone()
       }
-      if (!_yield!(tmp)) {
+      if (!await _yield!(tmp)) {
         return
       }
     }

package/gs/reflect/map.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { MapIter } from './map.js'
+import { AppendSlice, MakeMapWithSize, MapIter, MapOf, TypeOf, ValueOf } from './index.js'
 
 describe('MapIter', () => {
   it('should iterate over map entries with proper typing', () => {
@@ -29,3 +29,44 @@ 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([])
+  })
+})
+
+describe('reflect compatibility surface', () => {
+  it('constructs maps, ranges entries, and looks up values', () => {
+    const typ = MapOf(TypeOf(''), TypeOf(0))
+    const mapValue = MakeMapWithSize(typ, 4)
+    const raw = mapValue.Interface() as Map<string, number>
+    raw.set('alpha', 1)
+
+    const iter = mapValue.MapRange()
+
+    expect(iter?.Key().Interface()).toBe('alpha')
+    expect(mapValue.MapIndex(ValueOf('alpha')).Interface()).toBe(1)
+    expect(mapValue.Type().Comparable()).toBe(false)
+    expect(TypeOf('alpha').Comparable()).toBe(true)
+  })
+
+  it('slices and appends slice values', () => {
+    const sliced = ValueOf([1, 2, 3, 4]).Slice(1, 3)
+    const appended = AppendSlice(sliced, ValueOf([5, 6]))
+
+    expect(appended.Interface()).toEqual([2, 3, 5, 6])
+  })
+})

package/gs/reflect/map.ts

@@ -6,6 +6,7 @@ import {
   StructField,
   TypeOf,
 } from './type.js'
+import { Method } from './types.js'
 
 // Simple MapOf implementation using JavaScript Map
 export function MapOf(key: Type, elem: Type): Type {
@@ -27,10 +28,18 @@ class MapType implements Type {
     return MapKind // Map kind
   }
 
+  public Comparable(): boolean {
+    return false
+  }
+
   public Name(): string {
     return '' // Map types are unnamed composite types
   }
 
+  public PkgPath(): string {
+    return ''
+  }
+
   public Size(): number {
     return 8 // pointer size
   }
@@ -51,6 +60,16 @@ class MapType implements Type {
     throw new Error('reflect: Field of non-struct type map')
   }
 
+  public FieldByName(_name: string): [StructField, boolean] {
+    throw new Error('reflect: FieldByName of non-struct type map')
+  }
+
+  public FieldByNameFunc(
+    _match: (name: string) => boolean,
+  ): [StructField, boolean] {
+    throw new Error('reflect: FieldByNameFunc of non-struct type map')
+  }
+
   public Implements(u: Type | null): boolean {
     if (!u) {
       return false
@@ -62,6 +81,10 @@ class MapType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return u != null && this.String() === u.String()
+  }
+
   public OverflowInt(_x: number): boolean {
     throw new Error('reflect: OverflowInt of non-integer type map')
   }
@@ -78,6 +101,22 @@ class MapType implements Type {
     return 0
   }
 
+  public MethodByName(_name: string): [Method, boolean] {
+    return [
+      {
+        Name: '',
+        Type: TypeOf(null),
+        Func: () => undefined,
+        Index: 0,
+      },
+      false,
+    ]
+  }
+
+  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')
   }