goscript 0.2.2 → 0.2.4

package/gs/hash/fnv/index.ts

@@ -65,7 +65,10 @@ class FNV32 {
   }
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
-    return [appendBytes($.bytesToUint8Array(prefix), this.magic, be32(this.hash)), null]
+    return [
+      appendBytes($.bytesToUint8Array(prefix), this.magic, be32(this.hash)),
+      null,
+    ]
   }
 
   MarshalBinary(): [$.Bytes, $.GoError] {
@@ -136,7 +139,10 @@ class FNV64 {
   }
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
-    return [appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.hash)), null]
+    return [
+      appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.hash)),
+      null,
+    ]
   }
 
   MarshalBinary(): [$.Bytes, $.GoError] {
@@ -185,7 +191,11 @@ class FNV128 {
   }
 
   async Sum(prefix: $.Bytes | null): Promise<$.Bytes> {
-    return appendBytes($.bytesToUint8Array(prefix), be64(this.high()), be64(this.low()))
+    return appendBytes(
+      $.bytesToUint8Array(prefix),
+      be64(this.high()),
+      be64(this.low()),
+    )
   }
 
   Reset(): void {
@@ -202,7 +212,12 @@ class FNV128 {
 
   AppendBinary(prefix: $.Bytes | null): [$.Bytes, $.GoError] {
     return [
-      appendBytes($.bytesToUint8Array(prefix), this.magic, be64(this.high()), be64(this.low())),
+      appendBytes(
+        $.bytesToUint8Array(prefix),
+        this.magic,
+        be64(this.high()),
+        be64(this.low()),
+      ),
       null,
     ]
   }
@@ -217,7 +232,8 @@ class FNV128 {
     if (err != null) {
       return err
     }
-    this.hash = ((readBE64(state, 4) << 64n) | readBE64(state, 12)) & uint128Mask
+    this.hash =
+      ((readBE64(state, 4) << 64n) | readBE64(state, 12)) & uint128Mask
     return null
   }
 
@@ -304,11 +320,12 @@ function be64(value: bigint): Uint8Array {
 
 function readBE32(bytes: Uint8Array, offset: number): number {
   return (
-    ((bytes[offset] << 24) >>> 0) |
-    (bytes[offset + 1] << 16) |
-    (bytes[offset + 2] << 8) |
-    bytes[offset + 3]
-  ) >>> 0
+    (((bytes[offset] << 24) >>> 0) |
+      (bytes[offset + 1] << 16) |
+      (bytes[offset + 2] << 8) |
+      bytes[offset + 3]) >>>
+    0
+  )
 }
 
 function readBE64(bytes: Uint8Array, offset: number): bigint {

package/gs/io/fs/glob.ts

@@ -60,15 +60,18 @@ $.registerInterfaceType(
 // If fs implements [GlobFS], Glob calls fs.Glob.
 // Otherwise, Glob uses [ReadDir] to traverse the directory tree
 // and look for matches for the pattern.
-export function Glob(fsys: FS, pattern: string): [$.Slice<string>, $.GoError] {
-  return globWithLimit(fsys, pattern, 0)
+export async function Glob(
+  fsys: FS,
+  pattern: string,
+): Promise<[$.Slice<string>, $.GoError]> {
+  return await globWithLimit(fsys, pattern, 0)
 }
 
-export function globWithLimit(
+export async function globWithLimit(
   fsys: FS,
   pattern: string,
   depth: number,
-): [$.Slice<string>, $.GoError] {
+): Promise<[$.Slice<string>, $.GoError]> {
   let matches: $.Slice<string> = null
   {
     // This limit is added to prevent stack exhaustion issues. See
@@ -93,7 +96,7 @@ export function globWithLimit(
     }
     if (!hasMeta(pattern)) {
       {
-        const [, statErr] = Stat(fsys, pattern)
+        const [, statErr] = await Stat(fsys, pattern)
         if (statErr != null) {
           return [null, null]
         }
@@ -105,7 +108,7 @@ export function globWithLimit(
     dir = cleanGlobPath(dir)
 
     if (!hasMeta(dir)) {
-      return glob(fsys, dir, file, null)
+      return await glob(fsys, dir, file, null)
     }
 
     // Prevent infinite recursion. See issue 15879.
@@ -113,14 +116,14 @@ export function globWithLimit(
       return [null, path.ErrBadPattern]
     }
 
-    const [dirs, dirErr] = globWithLimit(fsys, dir, depth + 1)
+    const [dirs, dirErr] = await globWithLimit(fsys, dir, depth + 1)
     if (dirErr != null) {
       return [null, dirErr]
     }
     for (let _i = 0; _i < $.len(dirs); _i++) {
       const d = dirs![_i]
       {
-        const [nextMatches, globErr] = glob(fsys, d, file, matches)
+        const [nextMatches, globErr] = await glob(fsys, d, file, matches)
         matches = nextMatches
         if (globErr != null) {
           return [matches, globErr]
@@ -148,15 +151,15 @@ export function cleanGlobPath(path: string): string {
 // and appends them to matches, returning the updated slice.
 // If the directory cannot be opened, glob returns the existing matches.
 // New matches are added in lexicographical order.
-export function glob(
+export async function glob(
   fs: FS,
   dir: string,
   pattern: string,
   matches: $.Slice<string>,
-): [$.Slice<string>, $.GoError] {
+): Promise<[$.Slice<string>, $.GoError]> {
   let m = matches
   {
-    let [infos, err] = ReadDir(fs, dir)
+    let [infos, err] = await ReadDir(fs, dir)
 
     // ignore I/O error
     if (err != null) {

package/gs/io/fs/meta.json

@@ -1,5 +1,10 @@
 {
   "asyncFunctions": {
+    "Glob": true,
+    "Lstat": true,
+    "ReadDir": true,
+    "Stat": true,
+    "Sub": true,
     "WalkDir": true
   }
 }

package/gs/io/fs/readdir.test.ts

@@ -4,7 +4,7 @@ import * as $ from '@goscript/builtin/index.js'
 import { File, FileInfo, ReadDir } from './index.js'
 
 describe('io/fs ReadDir override', () => {
-  it('returns a nil entry slice without sorting when directory read fails', () => {
+  it('returns a nil entry slice without sorting when directory read fails', async () => {
     const readErr = $.newError('read failed')
     const file: File & {
       ReadDir(n: number): [null, $.GoError]
@@ -23,7 +23,7 @@ describe('io/fs ReadDir override', () => {
       },
     }
 
-    const [list, err] = ReadDir(
+    const [list, err] = await ReadDir(
       {
         Open(_name: string): [File, $.GoError] {
           return [file, null]
@@ -35,4 +35,65 @@ describe('io/fs ReadDir override', () => {
     expect(list).toBeNull()
     expect(err).toBe(readErr)
   })
+
+  it('awaits async FS.Open fallback implementations', async () => {
+    const entries = [
+      {
+        Name(): string {
+          return 'b.txt'
+        },
+        IsDir(): boolean {
+          return false
+        },
+        Info(): [FileInfo, $.GoError] {
+          return [null, null]
+        },
+        Type(): number {
+          return 0
+        },
+      },
+      {
+        Name(): string {
+          return 'a.txt'
+        },
+        IsDir(): boolean {
+          return false
+        },
+        Info(): [FileInfo, $.GoError] {
+          return [null, null]
+        },
+        Type(): number {
+          return 0
+        },
+      },
+    ]
+    const file: File & {
+      ReadDir(n: number): Promise<[$.Slice<any>, $.GoError]>
+    } = {
+      Close(): $.GoError {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      Stat(): [FileInfo, $.GoError] {
+        return [null, null]
+      },
+      async ReadDir(_n: number): Promise<[$.Slice<any>, $.GoError]> {
+        return [$.arrayToSlice(entries), null]
+      },
+    }
+
+    const [list, err] = await ReadDir(
+      {
+        async Open(_name: string): Promise<[File, $.GoError]> {
+          return [file, null]
+        },
+      },
+      'dir',
+    )
+
+    expect(err).toBeNull()
+    expect(list?.map((entry) => entry?.Name())).toEqual(['a.txt', 'b.txt'])
+  })
 })

package/gs/io/fs/readdir.ts

@@ -17,7 +17,11 @@ export type ReadDirFS =
   | ({
       // ReadDir reads the named directory
       // and returns a list of directory entries sorted by filename.
-      ReadDir(name: string): [$.Slice<DirEntry>, $.GoError]
+      ReadDir(
+        name: string,
+      ):
+        | [$.Slice<DirEntry>, $.GoError]
+        | Promise<[$.Slice<DirEntry>, $.GoError]>
     } & FS)
 
 $.registerInterfaceType(
@@ -55,51 +59,50 @@ $.registerInterfaceType(
 // If fs implements [ReadDirFS], ReadDir calls fs.ReadDir.
 // Otherwise ReadDir calls fs.Open and uses ReadDir and Close
 // on the returned file.
-export function ReadDir(
+export async function ReadDir(
   fsys: FS,
   name: string,
-): [$.Slice<DirEntry>, $.GoError] {
-  using __defer = new $.DisposableStack()
+): Promise<[$.Slice<DirEntry>, $.GoError]> {
   {
     let { value: fsysTyped, ok: ok } = $.typeAssert<ReadDirFS>(
       fsys,
       'ReadDirFS',
     )
     if (ok) {
-      return fsysTyped!.ReadDir(name)
+      return await fsysTyped!.ReadDir(name)
     }
   }
 
-  let [file, err] = fsys!.Open(name)
+  let [file, err] = await fsys!.Open(name)
   if (err != null) {
     return [null, err]
   }
-  __defer.defer(() => {
-    file!.Close()
-  })
-
-  let { value: dir, ok: ok } = $.typeAssert<ReadDirFile>(file, 'ReadDirFile')
-  if (!ok) {
-    return [
-      null,
-      new PathError({
-        Err: errors.New('not implemented'),
-        Op: 'readdir',
-        Path: name,
-      }),
-    ]
-  }
+  try {
+    let { value: dir, ok: ok } = $.typeAssert<ReadDirFile>(file, 'ReadDirFile')
+    if (!ok) {
+      return [
+        null,
+        new PathError({
+          Err: errors.New('not implemented'),
+          Op: 'readdir',
+          Path: name,
+        }),
+      ]
+    }
 
-  let list: $.Slice<DirEntry>
-  ;[list, err] = dir!.ReadDir(-1)
-  if (list) {
-    list.sort((a: DirEntry, b: DirEntry): number => {
-      return $.pointerValue<Exclude<DirEntry, null>>(a)
-        .Name()
-        .localeCompare($.pointerValue<Exclude<DirEntry, null>>(b).Name())
-    })
+    let list: $.Slice<DirEntry>
+    ;[list, err] = await dir!.ReadDir(-1)
+    if (list) {
+      list.sort((a: DirEntry, b: DirEntry): number => {
+        return $.pointerValue<Exclude<DirEntry, null>>(a)
+          .Name()
+          .localeCompare($.pointerValue<Exclude<DirEntry, null>>(b).Name())
+      })
+    }
+    return [list, err]
+  } finally {
+    await file!.Close()
   }
-  return [list, err]
 }
 
 class dirInfo {

package/gs/io/fs/readlink.test.ts

@@ -35,8 +35,8 @@ describe('io/fs ReadLink', () => {
     expect(err?.Error()).toBe('readlink link: invalid argument')
   })
 
-  it('uses Lstat from ReadLinkFS implementations', () => {
-    const [, err] = Lstat(new linkFS(), 'link')
+  it('uses Lstat from ReadLinkFS implementations', async () => {
+    const [, err] = await Lstat(new linkFS(), 'link')
 
     expect(err).toBe(ErrInvalid)
   })

package/gs/io/fs/readlink.ts

@@ -60,10 +60,13 @@ export function ReadLink(fsys: FS, name: string): [string, $.GoError] {
   return sym!.ReadLink(name)
 }
 
-export function Lstat(fsys: FS, name: string): [FileInfo, $.GoError] {
+export async function Lstat(
+  fsys: FS,
+  name: string,
+): Promise<[FileInfo, $.GoError]> {
   const { value: sym, ok } = $.typeAssert<ReadLinkFS>(fsys, 'ReadLinkFS')
   if (!ok) {
-    return Stat(fsys, name)
+    return await Stat(fsys, name)
   }
   return sym!.Lstat(name)
 }

package/gs/io/fs/stat.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { File, FileInfo, Stat } from './index.js'
+
+function fileInfo(name: string, isDir = false): FileInfo {
+  return {
+    IsDir(): boolean {
+      return isDir
+    },
+    ModTime(): any {
+      return null
+    },
+    Mode(): number {
+      return isDir ? 0o040000 : 0
+    },
+    Name(): string {
+      return name
+    },
+    Size(): number {
+      return 0
+    },
+    Sys(): null {
+      return null
+    },
+  }
+}
+
+describe('io/fs Stat override', () => {
+  it('awaits async StatFS implementations', async () => {
+    const info = fileInfo('pkg', true)
+
+    const [got, err] = await Stat(
+      {
+        async Stat(_name: string): Promise<[FileInfo, $.GoError]> {
+          return [info, null]
+        },
+        Open(_name: string): [File, $.GoError] {
+          throw new Error('StatFS path should not open')
+        },
+      },
+      'pkg',
+    )
+
+    expect(err).toBeNull()
+    expect(got).toBe(info)
+  })
+
+  it('awaits async Open, File.Stat, and Close fallback implementations', async () => {
+    const info = fileInfo('file.txt')
+    let closed = false
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        closed = true
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        expect(closed).toBe(false)
+        return [info, null]
+      },
+    } as unknown as File
+
+    const [got, err] = await Stat(
+      {
+        async Open(_name: string): Promise<[File, $.GoError]> {
+          return [file, null]
+        },
+      } as any,
+      'file.txt',
+    )
+
+    expect(err).toBeNull()
+    expect(got).toBe(info)
+    expect(closed).toBe(true)
+  })
+})

package/gs/io/fs/stat.ts

@@ -1,14 +1,25 @@
 import * as $ from '@goscript/builtin/index.js'
-import { FS, FileInfo } from './fs.js'
+import { FS, File, FileInfo } from './fs.js'
+
+type maybePromise<T> = T | Promise<T>
 
 export type StatFS =
   | null
   | ({
       // Stat returns a FileInfo describing the file.
       // If there is an error, it should be of type *PathError.
-      Stat(name: string): [FileInfo, $.GoError]
+      Stat(name: string): maybePromise<[FileInfo, $.GoError]>
     } & FS)
 
+type asyncFS = null | {
+  Open(name: string): maybePromise<[File, $.GoError]>
+}
+
+type asyncFile = null | {
+  Close(): maybePromise<$.GoError>
+  Stat(): maybePromise<[FileInfo, $.GoError]>
+}
+
 $.registerInterfaceType(
   'StatFS',
   null, // Zero value for interface is null
@@ -42,21 +53,24 @@ $.registerInterfaceType(
 //
 // If fs implements [StatFS], Stat calls fs.Stat.
 // Otherwise, Stat opens the [File] to stat it.
-export function Stat(fsys: FS, name: string): [FileInfo, $.GoError] {
-  using __defer = new $.DisposableStack()
+export async function Stat(
+  fsys: FS,
+  name: string,
+): Promise<[FileInfo, $.GoError]> {
   {
     let { value: fsysTyped, ok: ok } = $.typeAssert<StatFS>(fsys, 'StatFS')
     if (ok) {
-      return fsysTyped!.Stat(name)
+      return await fsysTyped!.Stat(name)
     }
   }
 
-  let [file, err] = fsys!.Open(name)
+  let [file, err] = await (fsys as asyncFS)!.Open(name)
   if (err != null) {
     return [null, err]
   }
-  __defer.defer(() => {
-    file!.Close()
-  })
-  return file!.Stat()
+  try {
+    return await (file as asyncFile)!.Stat()
+  } finally {
+    await (file as asyncFile)!.Close()
+  }
 }

package/gs/io/fs/sub.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { File, FileInfo, Sub, Stat } from './index.js'
+
+function fileInfo(name: string, isDir = false): FileInfo {
+  return {
+    IsDir(): boolean {
+      return isDir
+    },
+    ModTime(): any {
+      return null
+    },
+    Mode(): number {
+      return isDir ? 0o040000 : 0
+    },
+    Name(): string {
+      return name
+    },
+    Size(): number {
+      return 0
+    },
+    Sys(): null {
+      return null
+    },
+  }
+}
+
+describe('io/fs Sub override', () => {
+  it('preserves the backing filesystem and directory in fallback subFS', async () => {
+    const opened: string[] = []
+    const dirInfo = fileInfo('pkg', true)
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        return [dirInfo, null]
+      },
+    } as unknown as File
+
+    const [sub, subErr] = await Sub(
+      {
+        async Open(name: string): Promise<[File, $.GoError]> {
+          opened.push(name)
+          return [file, null]
+        },
+      } as any,
+      'pkg',
+    )
+    expect(subErr).toBeNull()
+
+    const [got, statErr] = await Stat(sub, '.')
+    expect(statErr).toBeNull()
+    expect(got).toBe(dirInfo)
+    expect(opened).toEqual(['pkg'])
+  })
+
+  it('joins nested fallback subFS directories', async () => {
+    const opened: string[] = []
+    const fileInfoValue = fileInfo('index.js')
+    const file: File = {
+      async Close(): Promise<$.GoError> {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, null]
+      },
+      async Stat(): Promise<[FileInfo, $.GoError]> {
+        return [fileInfoValue, null]
+      },
+    } as unknown as File
+
+    const backingFS = {
+      async Open(name: string): Promise<[File, $.GoError]> {
+        opened.push(name)
+        return [file, null]
+      },
+    } as any
+    const [pkgFS, pkgErr] = await Sub(backingFS, '@scope')
+    expect(pkgErr).toBeNull()
+    const [clientFS, clientErr] = await Sub(pkgFS, 'client')
+    expect(clientErr).toBeNull()
+
+    const [got, statErr] = await Stat(clientFS, 'index.js')
+    expect(statErr).toBeNull()
+    expect(got).toBe(fileInfoValue)
+    expect(opened).toEqual(['@scope/client/index.js'])
+  })
+})