goscript 0.1.3 → 0.2.0

package/gs/go/token/index.ts

@@ -285,12 +285,28 @@ export class Position {
       },
     ],
     Position,
-    {
-      Filename: { kind: $.TypeKind.Basic, name: 'string' },
-      Offset: { kind: $.TypeKind.Basic, name: 'int' },
-      Line: { kind: $.TypeKind.Basic, name: 'int' },
-      Column: { kind: $.TypeKind.Basic, name: 'int' },
-    },
+    [
+      {
+        name: 'Filename',
+        key: 'Filename',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+      {
+        name: 'Offset',
+        key: 'Offset',
+        type: { kind: $.TypeKind.Basic, name: 'int' },
+      },
+      {
+        name: 'Line',
+        key: 'Line',
+        type: { kind: $.TypeKind.Basic, name: 'int' },
+      },
+      {
+        name: 'Column',
+        key: 'Column',
+        type: { kind: $.TypeKind.Basic, name: 'int' },
+      },
+    ],
   )
 }
 

package/gs/hash/index.test.ts

@@ -1,37 +1,24 @@
 import { describe, expect, it } from 'vitest'
 
-import * as $ from '../builtin/index.js'
-
-import './index.js'
-
-class FakeHash {
-  Write(p: $.Bytes): [number, $.GoError] {
-    return [$.len(p), null]
-  }
-
-  Sum(b: $.Bytes): $.Bytes {
-    return b
-  }
-
-  Reset(): void {}
-
-  Size(): number {
-    return 20
-  }
-
-  BlockSize(): number {
-    return 64
-  }
-}
-
-describe('hash runtime contracts', () => {
-  it('registers Hash for runtime type assertions', () => {
-    const [value, ok] = $.typeAssertTuple<FakeHash>(
-      new FakeHash(),
-      'hash.Hash',
-    )
-
-    expect(ok).toBe(true)
-    expect(value).toBeInstanceOf(FakeHash)
+import * as $ from '@goscript/builtin/index.js'
+
+import type { XOF } from './index.js'
+
+describe('hash override', () => {
+  it('exports the XOF interface shape', () => {
+    const xof: XOF = {
+      Write(p: $.Bytes): [number, $.GoError] {
+        return [$.len(p), null]
+      },
+      Read(p: $.Bytes): [number, $.GoError] {
+        return [$.len(p), null]
+      },
+      Reset(): void {},
+      BlockSize(): number {
+        return 1
+      },
+    }
+
+    expect(xof.BlockSize()).toBe(1)
   })
 })

package/gs/hash/index.ts

@@ -16,6 +16,13 @@ export interface Hash64 extends Hash {
   Sum64(): bigint
 }
 
+export interface XOF {
+  Write(p: $.Bytes): [number, $.GoError]
+  Read(p: $.Bytes): [number, $.GoError]
+  Reset(): void
+  BlockSize(): number
+}
+
 export interface Cloner {
   Clone(): [Hash, $.GoError]
 }
@@ -116,3 +123,24 @@ $.registerInterfaceType('hash.Cloner', null, [
     ],
   },
 ])
+
+$.registerInterfaceType('hash.XOF', null, [
+  {
+    name: 'Write',
+    args: [{ name: 'p', type: bytesType }],
+    returns: [
+      { name: 'n', type: intType },
+      { name: 'err', type: errorType },
+    ],
+  },
+  {
+    name: 'Read',
+    args: [{ name: 'p', type: bytesType }],
+    returns: [
+      { name: 'n', type: intType },
+      { name: 'err', type: errorType },
+    ],
+  },
+  { name: 'Reset', args: [], returns: [] },
+  { name: 'BlockSize', args: [], returns: [{ name: '_r0', type: intType }] },
+])

package/gs/hash/parity.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "Cloner": {
+      "status": "real"
+    },
+    "Hash": {
+      "status": "real"
+    },
+    "Hash32": {
+      "status": "real"
+    },
+    "Hash64": {
+      "status": "real"
+    },
+    "XOF": {
+      "status": "real"
+    }
+  }
+}

package/gs/internal/goarch/index.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  ArchFamily,
+  BigEndian,
+  DefaultPhysPageSize,
+  GOARCH,
+  Int64Align,
+  IsAmd64,
+  IsWasm,
+  PCQuantum,
+  PtrBits,
+  PtrSize,
+  StackAlign,
+  WASM,
+} from './index.js'
+
+describe('internal/goarch override', () => {
+  it('matches JS/WASM Go architecture constants', () => {
+    expect(GOARCH).toBe('wasm')
+    expect(IsWasm).toBe(1)
+    expect(IsAmd64).toBe(0)
+    expect(PtrSize).toBe(8)
+    expect(PtrBits).toBe(64)
+    expect(Int64Align).toBe(PtrSize)
+    expect(StackAlign).toBe(PtrSize)
+    expect(BigEndian).toBe(false)
+    expect(DefaultPhysPageSize).toBe(65536)
+    expect(PCQuantum).toBe(1)
+    expect(ArchFamily).toBe(WASM)
+  })
+})

package/gs/internal/goarch/index.ts

@@ -1,18 +1,50 @@
-// Architecture constants for JavaScript/WebAssembly target
-// This replaces the auto-generated version with appropriate values for JS
+export type ArchFamilyType = number
 
-// Pointer size in bytes (64-bit in modern JavaScript environments)
-export const PtrSize = 8
+export const AMD64: ArchFamilyType = 0
+export const ARM: ArchFamilyType = 1
+export const ARM64: ArchFamilyType = 2
+export const I386: ArchFamilyType = 3
+export const LOONG64: ArchFamilyType = 4
+export const MIPS: ArchFamilyType = 5
+export const MIPS64: ArchFamilyType = 6
+export const PPC64: ArchFamilyType = 7
+export const RISCV64: ArchFamilyType = 8
+export const S390X: ArchFamilyType = 9
+export const WASM: ArchFamilyType = 10
 
-// JavaScript is little-endian
-export const BigEndian = false
+export const GOARCH = 'wasm'
 
-// Architecture family
-export const ArchFamily = 'wasm'
+export const Is386 = 0
+export const IsAmd64 = 0
+export const IsAmd64p32 = 0
+export const IsArm = 0
+export const IsArmbe = 0
+export const IsArm64 = 0
+export const IsArm64be = 0
+export const IsLoong64 = 0
+export const IsMips = 0
+export const IsMipsle = 0
+export const IsMips64 = 0
+export const IsMips64le = 0
+export const IsMips64p32 = 0
+export const IsMips64p32le = 0
+export const IsPpc = 0
+export const IsPpc64 = 0
+export const IsPpc64le = 0
+export const IsRiscv = 0
+export const IsRiscv64 = 0
+export const IsS390 = 0
+export const IsS390x = 0
+export const IsSparc = 0
+export const IsSparc64 = 0
+export const IsWasm = 1
 
-// Other common architecture constants
-export const Int64Align = 8
+export const PtrSize = 8
+export const PtrBits = PtrSize * 8
+export const Int64Align = PtrSize
+export const BigEndian = false
+export const ArchFamily: ArchFamilyType = WASM
+export const DefaultPhysPageSize = 65536
+export const PCQuantum = 1
 export const MinFrameSize = 0
-
-// CPU cache line size (not really applicable in JS, but some code might reference it)
-export const CacheLineSize = 64
+export const StackAlign = PtrSize

package/gs/internal/goarch/parity.json

@@ -0,0 +1,144 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "AMD64": {
+      "status": "real"
+    },
+    "ArchFamily": {
+      "status": "real"
+    },
+    "ArchFamilyType": {
+      "status": "real"
+    },
+    "ARM": {
+      "status": "real"
+    },
+    "ARM64": {
+      "status": "real"
+    },
+    "BigEndian": {
+      "status": "real"
+    },
+    "DefaultPhysPageSize": {
+      "status": "real"
+    },
+    "GOARCH": {
+      "status": "real"
+    },
+    "I386": {
+      "status": "real"
+    },
+    "Int64Align": {
+      "status": "real"
+    },
+    "Is386": {
+      "status": "real"
+    },
+    "IsAmd64": {
+      "status": "real"
+    },
+    "IsAmd64p32": {
+      "status": "real"
+    },
+    "IsArm": {
+      "status": "real"
+    },
+    "IsArm64": {
+      "status": "real"
+    },
+    "IsArm64be": {
+      "status": "real"
+    },
+    "IsArmbe": {
+      "status": "real"
+    },
+    "IsLoong64": {
+      "status": "real"
+    },
+    "IsMips": {
+      "status": "real"
+    },
+    "IsMips64": {
+      "status": "real"
+    },
+    "IsMips64le": {
+      "status": "real"
+    },
+    "IsMips64p32": {
+      "status": "real"
+    },
+    "IsMips64p32le": {
+      "status": "real"
+    },
+    "IsMipsle": {
+      "status": "real"
+    },
+    "IsPpc": {
+      "status": "real"
+    },
+    "IsPpc64": {
+      "status": "real"
+    },
+    "IsPpc64le": {
+      "status": "real"
+    },
+    "IsRiscv": {
+      "status": "real"
+    },
+    "IsRiscv64": {
+      "status": "real"
+    },
+    "IsS390": {
+      "status": "real"
+    },
+    "IsS390x": {
+      "status": "real"
+    },
+    "IsSparc": {
+      "status": "real"
+    },
+    "IsSparc64": {
+      "status": "real"
+    },
+    "IsWasm": {
+      "status": "real"
+    },
+    "LOONG64": {
+      "status": "real"
+    },
+    "MinFrameSize": {
+      "status": "real"
+    },
+    "MIPS": {
+      "status": "real"
+    },
+    "MIPS64": {
+      "status": "real"
+    },
+    "PCQuantum": {
+      "status": "real"
+    },
+    "PPC64": {
+      "status": "real"
+    },
+    "PtrBits": {
+      "status": "real"
+    },
+    "PtrSize": {
+      "status": "real"
+    },
+    "RISCV64": {
+      "status": "real"
+    },
+    "S390X": {
+      "status": "real"
+    },
+    "StackAlign": {
+      "status": "real"
+    },
+    "WASM": {
+      "status": "real"
+    }
+  }
+}

package/gs/io/fs/fs.ts

@@ -618,20 +618,32 @@ export class PathError {
       },
     ],
     PathError,
-    {
-      Op: { kind: $.TypeKind.Basic, name: 'string' },
-      Path: { kind: $.TypeKind.Basic, name: 'string' },
-      Err: {
-        kind: $.TypeKind.Interface,
-        name: 'GoError',
-        methods: [
-          {
-            name: 'Error',
-            args: [],
-            returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-          },
-        ],
+    [
+      {
+        name: 'Op',
+        key: 'Op',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
       },
-    },
+      {
+        name: 'Path',
+        key: 'Path',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+      {
+        name: 'Err',
+        key: 'Err',
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
+        },
+      },
+    ],
   )
 }

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

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest'
+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', () => {
+    const readErr = $.newError('read failed')
+    const file: File & {
+      ReadDir(n: number): [null, $.GoError]
+    } = {
+      Close(): $.GoError {
+        return null
+      },
+      Read(_p0: Uint8Array): [number, $.GoError] {
+        return [0, readErr]
+      },
+      Stat(): [FileInfo, $.GoError] {
+        return [null, readErr]
+      },
+      ReadDir(_n: number): [null, $.GoError] {
+        return [null, readErr]
+      },
+    }
+
+    const [list, err] = ReadDir(
+      {
+        Open(_name: string): [File, $.GoError] {
+          return [file, null]
+        },
+      },
+      'dir',
+    )
+
+    expect(list).toBeNull()
+    expect(err).toBe(readErr)
+  })
+})

package/gs/io/fs/readdir.ts

@@ -92,9 +92,13 @@ export function ReadDir(
 
   let list: $.Slice<DirEntry>
   ;[list, err] = dir!.ReadDir(-1)
-  list!.sort((a: DirEntry, b: DirEntry): number => {
-    return a!.Name().localeCompare(b!.Name())
-  })
+  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]
 }
 
@@ -194,7 +198,7 @@ class dirInfo {
       },
     ],
     dirInfo,
-    { fileInfo: 'FileInfo' },
+    [{ name: 'fileInfo', key: 'fileInfo', type: 'FileInfo' }],
   )
 }
 

package/gs/io/fs/sub.ts

@@ -444,6 +444,13 @@ class subFS {
       },
     ],
     subFS,
-    { fsys: 'FS', dir: { kind: $.TypeKind.Basic, name: 'string' } },
+    [
+      { name: 'fsys', key: 'fsys', type: 'FS' },
+      {
+        name: 'dir',
+        key: 'dir',
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+      },
+    ],
   )
 }

package/gs/io/io.test.ts

@@ -1,5 +1,5 @@
 import * as $ from '@goscript/builtin/index.js'
-import { LimitedReader, MultiWriter, TeeReader } from './index.js'
+import { LimitedReader, MultiWriter, NopCloser, Pipe, TeeReader } from './index.js'
 import { describe, expect, test } from 'vitest'
 
 class sliceReader {
@@ -9,7 +9,7 @@ class sliceReader {
     const n = Math.min($.len(p), this.data.length)
     p!.set(this.data.subarray(0, n), 0)
     this.data = this.data.subarray(n)
-    return [n, n === 0 ? new Error('EOF') as $.GoError : null]
+    return [n, n === 0 ? (new Error('EOF') as $.GoError) : null]
   }
 }
 
@@ -37,28 +37,99 @@ describe('io override', () => {
     expect(Buffer.from(buf.subarray(0, n)).toString('utf8')).toBe('abc')
   })
 
-  test('TeeReader accepts nullable generated interface values', () => {
+  test('TeeReader accepts nullable generated interface values', async () => {
     const writer = new captureWriter()
     const reader = TeeReader(new sliceReader($.stringToBytes('abc')), writer)
     const buf = new Uint8Array(4)
 
-    const [n, err] = reader.Read(buf)
+    const [n, err] = await reader.Read(buf)
 
     expect(err).toBeNull()
     expect(n).toBe(3)
     expect(Buffer.from(writer.chunks).toString('utf8')).toBe('abc')
   })
 
-  test('MultiWriter accepts nullable generated interface values', () => {
+  test('NopCloser accepts nullable generated interface values', () => {
+    const reader: sliceReader | null = new sliceReader($.stringToBytes('abc'))
+    const body = NopCloser(reader)
+    const buf = new Uint8Array(4)
+
+    const [n, err] = body.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(body.Close()).toBeNull()
+  })
+
+  test('TeeReader awaits async readers and writers', async () => {
+    const chunks: number[] = []
+    const reader = TeeReader(
+      {
+        async Read(p: $.Bytes): Promise<[number, $.GoError]> {
+          await Promise.resolve()
+          p!.set($.stringToBytes('abc'), 0)
+          return [3, null]
+        },
+      } as any,
+      {
+        async Write(p: $.Bytes): Promise<[number, $.GoError]> {
+          await Promise.resolve()
+          chunks.push(...Array.from(p ?? []))
+          return [$.len(p), null]
+        },
+      } as any,
+    )
+    const buf = new Uint8Array(4)
+
+    const [n, err] = await reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('MultiWriter accepts nullable generated interface values', async () => {
     const first = new captureWriter()
     const second = new captureWriter()
     const writer = MultiWriter(first, second)
 
-    const [n, err] = writer.Write($.stringToBytes('abc'))
+    const [n, err] = await writer.Write($.stringToBytes('abc'))
 
     expect(err).toBeNull()
     expect(n).toBe(3)
     expect(Buffer.from(first.chunks).toString('utf8')).toBe('abc')
     expect(Buffer.from(second.chunks).toString('utf8')).toBe('abc')
   })
+
+  test('MultiWriter awaits async generated writers', async () => {
+    const chunks: number[] = []
+    const writer = MultiWriter({
+      async Write(p: $.Bytes): Promise<[number, $.GoError]> {
+        await Promise.resolve()
+        chunks.push(...Array.from(p ?? []))
+        return [$.len(p), null]
+      },
+    })
+
+    const [n, err] = await writer.Write($.stringToBytes('abc'))
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(chunks).toString('utf8')).toBe('abc')
+  })
+
+  test('PipeReader waits for a later write', async () => {
+    const [reader, writer] = Pipe()
+    const buf = new Uint8Array(5)
+
+    const read = reader.Read(buf)
+    const [written, writeErr] = await writer.Write($.stringToBytes('later'))
+    const [readBytes, readErr] = await read
+
+    expect(writeErr).toBeNull()
+    expect(written).toBe(5)
+    expect(readErr).toBeNull()
+    expect(readBytes).toBe(5)
+    expect(Buffer.from(buf).toString('utf8')).toBe('later')
+  })
 })