goscript 0.1.1 → 0.1.3

package/gs/os/error.gs.ts

@@ -184,6 +184,9 @@ export function underlyingErrorIs(err: $.GoError, target: $.GoError): boolean {
 	if (err == target) {
 		return true
 	}
+	if (err !== null && typeof (err as any).Is === "function") {
+		return (err as any).Is(target) === true
+	}
 	// To preserve prior behavior, only examine syscall errors.
 	let { value: e, ok: ok } = $.typeAssert<any>(err, 'syscallErrorType')
 	return ok && e.Is(target)
@@ -191,15 +194,11 @@ export function underlyingErrorIs(err: $.GoError, target: $.GoError): boolean {
 
 // underlyingError returns the underlying error for known os error types.
 export function underlyingError(err: $.GoError): $.GoError {
-	$.typeSwitch(err, [{ types: [{kind: $.TypeKind.Pointer, elemType: 'PathError'}], body: (err) => {
-		return err!.Err
-	}},
-	{ types: [{kind: $.TypeKind.Pointer, elemType: 'LinkError'}], body: (err) => {
-		return err!.Err
-	}},
-	{ types: [{kind: $.TypeKind.Pointer, elemType: 'SyscallError'}], body: (err) => {
-		return err!.Err
-	}}])
+	if (err !== null && typeof (err as any).Unwrap === "function") {
+		const unwrapped = (err as any).Unwrap()
+		if (unwrapped !== null && typeof unwrapped?.Error === "function") {
+			return unwrapped
+		}
+	}
 	return err
 }
-

package/gs/os/error.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  ErrNotExist,
+  IsExist,
+  IsNotExist,
+  IsPermission,
+  PathError,
+} from './error.gs.js'
+import { newHostError } from './types_js.gs.js'
+
+function hostError(code: string): Error {
+  return Object.assign(new Error(code), { code })
+}
+
+describe('os error classification', () => {
+  it('unwraps path errors before comparing sentinel errors', () => {
+    const err = new PathError({
+      Err: ErrNotExist,
+      Op: 'open',
+      Path: 'missing',
+    })
+
+    expect(IsNotExist(err)).toBe(true)
+    expect(IsExist(err)).toBe(false)
+  })
+
+  it('recognizes host filesystem error codes', () => {
+    expect(IsNotExist(newHostError(hostError('ENOENT')))).toBe(true)
+    expect(IsNotExist(newHostError(hostError('ENOTDIR')))).toBe(true)
+    expect(IsExist(newHostError(hostError('EEXIST')))).toBe(true)
+    expect(IsPermission(newHostError(hostError('EACCES')))).toBe(true)
+    expect(IsPermission(newHostError(hostError('EPERM')))).toBe(true)
+  })
+
+  it('does not treat unrelated host errors as filesystem sentinels', () => {
+    expect(IsNotExist(newHostError(hostError('EIO')))).toBe(false)
+    expect(IsExist(newHostError(hostError('EIO')))).toBe(false)
+    expect(IsPermission(newHostError(hostError('EIO')))).toBe(false)
+  })
+})

package/gs/os/file_unix_js.test.ts

@@ -231,4 +231,59 @@ describe('os stdio', () => {
     expect(handle.writeSync).toHaveBeenCalledTimes(2)
     expect(Array.from(handle.writeSync.mock.calls[1][0])).toEqual([22, 23])
   })
+
+  it('supports ReadAt and WriteAt on process fs descriptors', () => {
+    const readSync = vi.fn(
+      (
+        _fd: number,
+        buffer: Uint8Array,
+        offset?: number,
+        length?: number,
+        position?: number | null,
+      ) => {
+        expect(offset).toBe(0)
+        expect(length).toBe(3)
+        expect(position).toBe(5)
+        buffer.set([31, 32, 33], 0)
+        return 3
+      },
+    )
+    const writeSync = vi.fn(
+      (
+        _fd: number,
+        _buffer: Uint8Array,
+        offset?: number,
+        length?: number,
+        position?: number | null,
+      ) => {
+        expect(offset).toBe(0)
+        expect(length).toBe(2)
+        expect(position).toBe(8)
+        return length ?? 0
+      },
+    )
+
+    delete (globalThis as any).Deno
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync,
+        writeSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    const file = createHostFile('descriptor-file', 7)
+    const buf = new Uint8Array(3)
+
+    const [readN, readErr] = file.ReadAt(buf, 5)
+    expect(readN).toBe(3)
+    expect(readErr).toBeNull()
+    expect(Array.from(buf)).toEqual([31, 32, 33])
+
+    const [writeN, writeErr] = file.WriteAt(new Uint8Array([41, 42]), 8)
+    expect(writeN).toBe(2)
+    expect(writeErr).toBeNull()
+    expect(readSync).toHaveBeenCalledTimes(1)
+    expect(writeSync).toHaveBeenCalledTimes(1)
+  })
 })

package/gs/os/tempfile.gs.test.ts

@@ -1,16 +1,29 @@
 import { basename, join } from 'node:path'
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import { ErrUnimplemented } from './error.gs.js'
 import { CreateTemp, MkdirTemp } from './tempfile.gs.js'
+import * as errors from '../errors/errors.js'
+import { ErrNotExist } from './error.gs.js'
+import { Stat } from './stat_js.gs.js'
 
 const tempRoots: string[] = []
+const originalCrypto = globalThis.crypto
 
 afterEach(() => {
   vi.restoreAllMocks()
-  vi.unstubAllGlobals()
+  Object.defineProperty(globalThis, 'crypto', {
+    configurable: true,
+    value: originalCrypto,
+  })
   for (const root of tempRoots.splice(0)) {
     rmSync(root, { force: true, recursive: true })
   }
@@ -23,13 +36,16 @@ function makeTempRoot(): string {
 }
 
 function stubRandomBytes(bytes: number[]): void {
-  vi.stubGlobal('crypto', {
-    getRandomValues: vi.fn((dst: Uint8Array) => {
-      for (let i = 0; i < dst.length; i++) {
-        dst[i] = bytes[i] ?? 0
-      }
-      return dst
-    }),
+  Object.defineProperty(globalThis, 'crypto', {
+    configurable: true,
+    value: {
+      getRandomValues: vi.fn((dst: Uint8Array) => {
+        for (let i = 0; i < dst.length; i++) {
+          dst[i] = bytes[i] ?? 0
+        }
+        return dst
+      }),
+    },
   })
 }
 
@@ -74,7 +90,10 @@ describe('os temp files', () => {
 
   it('reports ErrUnimplemented without a secure random source', () => {
     const root = makeTempRoot()
-    vi.stubGlobal('crypto', {})
+    Object.defineProperty(globalThis, 'crypto', {
+      configurable: true,
+      value: {},
+    })
     forbidMathRandom()
 
     const [dir, err] = MkdirTemp(root, 'dir-*')
@@ -82,4 +101,12 @@ describe('os temp files', () => {
     expect(dir).toBe('')
     expect(err).toBe(ErrUnimplemented)
   })
+
+  it('maps host missing-path errors to ErrNotExist', () => {
+    const root = makeTempRoot()
+
+    const [, err] = Stat(join(root, 'missing'))
+
+    expect(errors.Is(err, ErrNotExist)).toBe(true)
+  })
 })

package/gs/os/types_js.gs.ts

@@ -29,7 +29,37 @@ export function newHostError(err: unknown): $.GoError {
 		err instanceof Error ? err.message
 		: typeof err === "string" ? err
 		: String(err)
-	return { Error: () => message }
+	const target = hostErrorTarget(err)
+	const hostErr: Exclude<$.GoError, null> = {
+		Error: () => message,
+	}
+	Object.defineProperty(hostErr, "Is", {
+		value: (candidate: $.GoError) => target !== null && candidate === target,
+	})
+	return hostErr
+}
+
+function hostErrorTarget(err: unknown): $.GoError {
+	const codeValue = typeof err === "object" && err !== null && "code" in err
+		? Reflect.get(err, "code")
+		: ""
+	const code = codeValue === undefined ? "" : String(codeValue)
+	switch (code) {
+	case "ENOENT":
+	case "ENOTDIR":
+		return fs.ErrNotExist
+	case "EEXIST":
+		return fs.ErrExist
+	case "EACCES":
+	case "EPERM":
+		return fs.ErrPermission
+	case "EBADF":
+		return ErrClosed
+	case "EINVAL":
+		return ErrInvalid
+	default:
+		return null
+	}
 }
 
 export function getNodeFS(): NodeFSModule | null {
@@ -296,16 +326,44 @@ export class File {
 	}
 
 	public ReadAt(b: $.Bytes, off: number): [number, $.GoError] {
+		if (this.closed) {
+			return [0, ErrClosed]
+		}
+		if (off < 0) {
+			return [0, ErrInvalid]
+		}
+		if (b === null) {
+			return [0, null]
+		}
+		const buf = $.bytesToUint8Array(b)
 		const handle = this.file?.handle
-		if (!handle || typeof handle.seekSync !== "function" || b === null) {
-			return [0, ErrUnimplemented]
+		if (handle && typeof handle.seekSync === "function") {
+			try {
+				handle.seekSync(off, io.SeekStart)
+				return this.Read(b)
+			} catch (err) {
+				return [0, newHostError(err)]
+			}
 		}
-		try {
-			handle.seekSync(off, io.SeekStart)
-			return this.Read(b)
-		} catch (err) {
-			return [0, newHostError(err)]
+		if (this.fd < 0) {
+			return [0, ErrInvalid]
+		}
+		const nodeFS = getNodeFS()
+		if (nodeFS?.readSync && this.fd >= 0) {
+			try {
+				const n = nodeFS.readSync(this.fd, buf, 0, buf.length, off)
+				if (!(b instanceof Uint8Array) && n > 0) {
+					$.copy(b, buf.subarray(0, n))
+				}
+				if (n === 0) {
+					return [0, io.EOF]
+				}
+				return [n, null]
+			} catch (err) {
+				return [0, newHostError(err)]
+			}
 		}
+		return [0, ErrUnimplemented]
 	}
 
 	public ReadFrom(r: io.Reader): [number, $.GoError] {
@@ -333,16 +391,37 @@ export class File {
 	}
 
 	public WriteAt(b: $.Bytes, off: number): [number, $.GoError] {
+		if (this.closed) {
+			return [0, ErrClosed]
+		}
+		if (off < 0) {
+			return [0, ErrInvalid]
+		}
+		if (b === null) {
+			return [0, null]
+		}
+		const buf = $.bytesToUint8Array(b)
 		const handle = this.file?.handle
-		if (!handle || typeof handle.seekSync !== "function" || b === null) {
-			return [0, ErrUnimplemented]
+		if (handle && typeof handle.seekSync === "function") {
+			try {
+				handle.seekSync(off, io.SeekStart)
+				return this.Write(b)
+			} catch (err) {
+				return [0, newHostError(err)]
+			}
 		}
-		try {
-			handle.seekSync(off, io.SeekStart)
-			return this.Write(b)
-		} catch (err) {
-			return [0, newHostError(err)]
+		if (this.fd < 0) {
+			return [0, ErrInvalid]
 		}
+		const nodeFS = getNodeFS()
+		if (nodeFS?.writeSync && this.fd >= 0) {
+			try {
+				return [nodeFS.writeSync(this.fd, buf, 0, buf.length, off), null]
+			} catch (err) {
+				return [0, newHostError(err)]
+			}
+		}
+		return [0, ErrUnimplemented]
 	}
 
 	public WriteTo(w: io.Writer): [number, $.GoError] {

package/gs/os/zero_copy_posix.gs.ts

@@ -30,6 +30,5 @@ export function tryLimitedReader(r: io.Reader): [io.LimitedReader | null, io.Rea
 	}
 
 	remain = lr!.N
-	return [lr, lr!.R, remain]
+	return [lr, lr!.R ?? r, remain]
 }
-

package/gs/path/filepath/match.ts

@@ -251,7 +251,10 @@ function hasMeta(path: string): boolean {
   return /[*?[\\]/.test(path)
 }
 
-function splitPattern(pattern: string): { absolute: boolean; segments: string[] } {
+function splitPattern(pattern: string): {
+  absolute: boolean
+  segments: string[]
+} {
   const absolute = pattern.startsWith('/')
   const segments = pattern.split('/').filter((segment, index) => {
     if (index === 0 && segment === '') {

package/gs/path/filepath/meta.json

@@ -0,0 +1,6 @@
+{
+  "asyncFunctions": {
+    "Walk": true,
+    "WalkDir": true
+  }
+}

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

@@ -20,6 +20,8 @@ import {
   Rel,
   EvalSymlinks,
   Walk,
+  WalkDir,
+  SkipDir,
   Separator,
   ListSeparator,
 } from './path.js'
@@ -206,14 +208,14 @@ describe('path/filepath - Path manipulation functions', () => {
   })
 
   describe('Walk', () => {
-    it('should visit host filesystem paths in lexical order', () => {
+    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 = Walk(root, (path) => {
+        const err = await Walk(root, (path) => {
           visited.push(path.slice(root.length).replace(/^\/?/, '') || '.')
           return null
         })
@@ -226,6 +228,59 @@ describe('path/filepath - Path manipulation functions', () => {
     })
   })
 
+  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

@@ -2,6 +2,8 @@
 // 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>
 
@@ -320,15 +322,27 @@ 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 {
-  return walkHost(root, walkFn)
+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
@@ -374,6 +388,10 @@ function fileInfo(path: string, stat: HostStat): any {
   }
 }
 
+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) {
@@ -433,13 +451,13 @@ function readDir(path: string): [HostEntry[] | null, $.GoError] {
   return [null, $.newError('filesystem not supported')]
 }
 
-function walkHost(path: string, walkFn: WalkFunc): $.GoError {
+async function walkHost(path: string, walkFn: WalkFunc): Promise<$.GoError> {
   const [stat, statErr] = statPath(path)
   if (statErr !== null) {
-    return walkFn(path, null, statErr)
+    return await walkFn(path, null, statErr)
   }
 
-  const visitErr = walkFn(path, fileInfo(path, stat!), null)
+  const visitErr = await walkFn(path, fileInfo(path, stat!), null)
   if (visitErr === SkipAll) {
     return null
   }
@@ -455,10 +473,71 @@ function walkHost(path: string, walkFn: WalkFunc): $.GoError {
 
   const [entries, readErr] = readDir(path)
   if (readErr !== null) {
-    return walkFn(path, fileInfo(path, stat!), readErr)
+    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 = walkHost(Join(path, entry.name), walkFn)
+    const err = await walkDirHost(Join(path, entry.name), walkFn)
     if (err === SkipDir) {
       if (entry.isDir) {
         continue

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')
+  })
+})