goscript 0.1.1 → 0.1.3

package/gs/io/fs/readlink.ts

@@ -9,56 +9,48 @@ export type ReadLinkFS =
       Lstat(name: string): [FileInfo, $.GoError]
     } & FS)
 
-$.registerInterfaceType(
-  'ReadLinkFS',
-  null,
-  [
-    {
-      name: 'ReadLink',
-      args: [
-        { name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } },
-      ],
-      returns: [
-        { type: { kind: $.TypeKind.Basic, name: 'string' } },
-        {
-          type: {
-            kind: $.TypeKind.Interface,
-            name: 'GoError',
-            methods: [
-              {
-                name: 'Error',
-                args: [],
-                returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-              },
-            ],
-          },
+$.registerInterfaceType('ReadLinkFS', null, [
+  {
+    name: 'ReadLink',
+    args: [{ name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    returns: [
+      { type: { kind: $.TypeKind.Basic, name: 'string' } },
+      {
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
         },
-      ],
-    },
-    {
-      name: 'Lstat',
-      args: [
-        { name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } },
-      ],
-      returns: [
-        { type: 'FileInfo' },
-        {
-          type: {
-            kind: $.TypeKind.Interface,
-            name: 'GoError',
-            methods: [
-              {
-                name: 'Error',
-                args: [],
-                returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
-              },
-            ],
-          },
+      },
+    ],
+  },
+  {
+    name: 'Lstat',
+    args: [{ name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    returns: [
+      { type: 'FileInfo' },
+      {
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
         },
-      ],
-    },
-  ],
-)
+      },
+    ],
+  },
+])
 
 export function ReadLink(fsys: FS, name: string): [string, $.GoError] {
   const { value: sym, ok } = $.typeAssert<ReadLinkFS>(fsys, 'ReadLinkFS')

package/gs/io/fs/walk.ts

@@ -12,7 +12,11 @@ export let SkipDir: $.GoError = errors.New('skip this directory')
 export let SkipAll: $.GoError = errors.New('skip everything and stop the walk')
 
 export type WalkDirFunc =
-  | ((path: string, d: DirEntry, err: $.GoError) => $.GoError | Promise<$.GoError>)
+  | ((
+      path: string,
+      d: DirEntry,
+      err: $.GoError,
+    ) => $.GoError | Promise<$.GoError>)
   | null
 
 // walkDir recursively descends path, calling walkDirFn.
@@ -79,7 +83,11 @@ export async function walkDir(
 //
 // WalkDir does not follow symbolic links found in directories,
 // but if root itself is a symbolic link, its target will be walked.
-export async function WalkDir(fsys: FS, root: string, fn: WalkDirFunc): Promise<$.GoError> {
+export async function WalkDir(
+  fsys: FS,
+  root: string,
+  fn: WalkDirFunc,
+): Promise<$.GoError> {
   let [info, err] = Stat(fsys, root)
   if (err != null) {
     err = await fn!(root, null, err)

package/gs/io/io.test.ts

@@ -0,0 +1,64 @@
+import * as $ from '@goscript/builtin/index.js'
+import { LimitedReader, MultiWriter, TeeReader } from './index.js'
+import { describe, expect, test } from 'vitest'
+
+class sliceReader {
+  constructor(private data: Uint8Array) {}
+
+  Read(p: $.Bytes): [number, $.GoError] {
+    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]
+  }
+}
+
+class captureWriter {
+  public chunks: number[] = []
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    this.chunks.push(...Array.from(p ?? []))
+    return [$.len(p), null]
+  }
+}
+
+describe('io override', () => {
+  test('LimitedReader accepts generated struct-literal construction', async () => {
+    const reader = new LimitedReader({
+      R: new sliceReader($.stringToBytes('abcdef')),
+      N: 3,
+    })
+    const buf = new Uint8Array(8)
+
+    const [n, err] = await reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(3)
+    expect(Buffer.from(buf.subarray(0, n)).toString('utf8')).toBe('abc')
+  })
+
+  test('TeeReader accepts nullable generated interface values', () => {
+    const writer = new captureWriter()
+    const reader = TeeReader(new sliceReader($.stringToBytes('abc')), writer)
+    const buf = new Uint8Array(4)
+
+    const [n, err] = 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', () => {
+    const first = new captureWriter()
+    const second = new captureWriter()
+    const writer = MultiWriter(first, second)
+
+    const [n, err] = 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')
+  })
+})

package/gs/io/io.ts

@@ -232,7 +232,7 @@ class DiscardWriter implements Writer {
   }
 }
 
-export const Discard: Writer = new DiscardWriter()
+export const Discard: Writer | null = new DiscardWriter()
 
 // WriteString writes the contents of the string s to w, which accepts a slice of bytes
 export function WriteString(w: Writer, s: string): [number, $.GoError] {
@@ -248,12 +248,18 @@ export function WriteString(w: Writer, s: string): [number, $.GoError] {
 
 // LimitedReader reads from R but limits the amount of data returned to just N bytes
 export class LimitedReader implements Reader {
-  public R: Reader
+  public R: Reader | null
   public N: number
 
-  constructor(r: Reader, n: number) {
-    this.R = r
-    this.N = n
+  constructor(r?: Reader | { R?: Reader | null; N?: number } | null, n?: number) {
+    if (r != null && typeof (r as { Read?: unknown }).Read !== 'function') {
+      const init = r as { R?: Reader | null; N?: number }
+      this.R = init.R ?? null
+      this.N = init.N ?? 0
+      return
+    }
+    this.R = (r as Reader | null | undefined) ?? null
+    this.N = n ?? 0
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
@@ -261,6 +267,9 @@ export class LimitedReader implements Reader {
       if (this.N <= 0) {
         return [0, EOF]
       }
+      if (this.R == null) {
+        throw new Error('io.LimitedReader: nil reader')
+      }
 
       let readBuf = p
       if ($.len(p) > this.N) {
@@ -547,7 +556,10 @@ export async function ReadAtLeast(
 }
 
 // ReadFull reads exactly len(buf) bytes from r into buf
-export async function ReadFull(r: Reader, buf: $.Bytes): Promise<[number, $.GoError]> {
+export async function ReadFull(
+  r: Reader,
+  buf: $.Bytes,
+): Promise<[number, $.GoError]> {
   return await ReadAtLeast(r, buf, $.len(buf))
 }
 
@@ -642,19 +654,22 @@ class multiReader implements Reader {
 }
 
 // MultiWriter creates a writer that duplicates its writes to all the provided writers
-export function MultiWriter(...writers: Writer[]): Writer {
+export function MultiWriter(...writers: (Writer | null)[]): Writer {
   return new multiWriter(writers.slice())
 }
 
 class multiWriter implements Writer {
-  private writers: Writer[]
+  private writers: (Writer | null)[]
 
-  constructor(writers: Writer[]) {
+  constructor(writers: (Writer | null)[]) {
     this.writers = writers
   }
 
   Write(p: $.Bytes): [number, $.GoError] {
     for (const w of this.writers) {
+      if (w == null) {
+        throw new Error('io.MultiWriter: nil writer')
+      }
       const [n, err] = w.Write(p)
       if (err !== null) {
         return [n, err]
@@ -668,22 +683,28 @@ class multiWriter implements Writer {
 }
 
 // TeeReader returns a Reader that writes to w what it reads from r
-export function TeeReader(r: Reader, w: Writer): Reader {
+export function TeeReader(r: Reader | null, w: Writer | null): Reader {
   return new teeReader(r, w)
 }
 
 class teeReader implements Reader {
-  private r: Reader
-  private w: Writer
+  private r: Reader | null
+  private w: Writer | null
 
-  constructor(r: Reader, w: Writer) {
+  constructor(r: Reader | null, w: Writer | null) {
     this.r = r
     this.w = w
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
+    if (this.r == null) {
+      throw new Error('io.TeeReader: nil reader')
+    }
     const [n, err] = this.r.Read(p)
     if (n > 0) {
+      if (this.w == null) {
+        throw new Error('io.TeeReader: nil writer')
+      }
       const [nw, ew] = this.w.Write($.goSlice(p, 0, n))
       if (ew !== null) {
         return [n, ew]

package/gs/iter/iter.ts

@@ -1,11 +1,17 @@
 // TypeScript implementation of Go's iter package
 // This provides iterator types and functions
 
+export type YieldResult = boolean | globalThis.Promise<boolean>
+
 // Seq is an iterator over sequences of individual values
-export type Seq<V> = (_yield: (value: V) => boolean) => void
+export type Seq<V> = (
+  _yield: ((value: V) => YieldResult) | null,
+) => void | globalThis.Promise<void>
 
 // Seq2 is an iterator over sequences of pairs of values
-export type Seq2<K, V> = (_yield: (key: K, value: V) => boolean) => void
+export type Seq2<K, V> = (
+  _yield: ((key: K, value: V) => YieldResult) | null,
+) => void | globalThis.Promise<void>
 
 // Pull converts the "push-style" iterator sequence seq into a "pull-style" iterator
 // Returns a function that returns the next value and a boolean indicating if iteration should continue

package/gs/maps/iter.ts

@@ -5,51 +5,39 @@ import * as iter from '@goscript/iter/index.js'
 // All returns an iterator over key-value pairs from m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function All<K extends $.Comparable, V>(
+export function All<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq2<K, V> {
-  return (_yield: ((p0: K, p1: V) => boolean) | null): void => {
-    for (const [k, v] of m?.entries() ?? []) {
-      if (!_yield!(k, v)) {
-        return
-      }
-    }
-  }
+  return (_yield: ((p0: K, p1: V) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iteratePairs(m?.entries() ?? [], _yield)
 }
 
 // Keys returns an iterator over keys in m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function Keys<K extends $.Comparable, V>(
+export function Keys<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq<K> {
-  return (_yield: ((p0: K) => boolean) | null): void => {
-    for (const [k, _v] of m?.entries() ?? []) {
-      if (!_yield!(k)) {
-        return
-      }
-    }
-  }
+  return (_yield: ((p0: K) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iterateValues(mapKeys(m), _yield)
 }
 
 // Values returns an iterator over values in m.
 // The iteration order is not specified and is not guaranteed
 // to be the same from one call to the next.
-export function Values<K extends $.Comparable, V>(
+export function Values<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): iter.Seq<V> {
-  return (_yield: ((p0: V) => boolean) | null): void => {
-    for (const [_k, v] of m?.entries() ?? []) {
-      if (!_yield!(v)) {
-        return
-      }
-    }
-  }
+  return (_yield: ((p0: V) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iterateValues(mapValues(m), _yield)
 }
 
 // Insert adds the key-value pairs from seq to m.
 // If a key in seq already exists in m, its value will be overwritten.
-export function Insert<K extends $.Comparable, V>(
+export function Insert<K extends $.Comparable | null, V>(
   m: Map<K, V>,
   seq: iter.Seq2<K, V>,
 ): void {
@@ -64,10 +52,65 @@ export function Insert<K extends $.Comparable, V>(
 
 // Collect collects key-value pairs from seq into a new map
 // and returns it.
-export function Collect<K extends $.Comparable, V>(
+export function Collect<K extends $.Comparable | null, V>(
   seq: iter.Seq2<K, V>,
 ): Map<K, V> {
   let m = $.makeMap<K, V>()
   Insert(m, seq)
   return m
 }
+
+function mapKeys<K extends $.Comparable | null, V>(m: Map<K, V> | null): K[] {
+  return Array.from(m?.keys() ?? [])
+}
+
+function mapValues<K extends $.Comparable | null, V>(m: Map<K, V> | null): V[] {
+  return Array.from(m?.values() ?? [])
+}
+
+function iterateValues<T>(
+  values: Iterable<T>,
+  yieldValue: ((value: T) => iter.YieldResult) | null,
+): void | globalThis.Promise<void> {
+  const items = Array.from(values)
+  const walk = (idx: number): void | globalThis.Promise<void> => {
+    for (; idx < items.length; idx++) {
+      const keepGoing = yieldValue!(items[idx])
+      if (keepGoing instanceof Promise) {
+        return keepGoing.then((next) => {
+          if (next) {
+            return walk(idx + 1)
+          }
+        })
+      }
+      if (!keepGoing) {
+        return
+      }
+    }
+  }
+  return walk(0)
+}
+
+function iteratePairs<K, V>(
+  entries: Iterable<[K, V]>,
+  yieldValue: ((key: K, value: V) => iter.YieldResult) | null,
+): void | globalThis.Promise<void> {
+  const items = Array.from(entries)
+  const walk = (idx: number): void | globalThis.Promise<void> => {
+    for (; idx < items.length; idx++) {
+      const [key, value] = items[idx]
+      const keepGoing = yieldValue!(key, value)
+      if (keepGoing instanceof Promise) {
+        return keepGoing.then((next) => {
+          if (next) {
+            return walk(idx + 1)
+          }
+        })
+      }
+      if (!keepGoing) {
+        return
+      }
+    }
+  }
+  return walk(0)
+}

package/gs/maps/maps.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { Clone, Values } from './index.js'
+
+describe('maps overrides', () => {
+  it('accept nilable comparable keys', () => {
+    const source = new Map<object | null, number>()
+    const key = { name: 'type' }
+    source.set(null, 1)
+    source.set(key, 2)
+
+    const cloned = Clone(source)
+    expect(cloned?.get(null)).toBe(1)
+    expect(cloned?.get(key)).toBe(2)
+
+    const values: number[] = []
+    Values(cloned)((value) => {
+      values.push(value)
+      return true
+    })
+    expect(values.sort()).toEqual([1, 2])
+  })
+})

package/gs/maps/maps.ts

@@ -4,7 +4,7 @@ import * as _ from '@goscript/unsafe/index.js'
 
 // Equal reports whether two maps contain the same key/value pairs.
 // Values are compared using ==.
-export function Equal<K extends $.Comparable, V extends $.Comparable>(
+export function Equal<K extends $.Comparable | null, V extends $.Comparable | null>(
   m1: Map<K, V>,
   m2: Map<K, V>,
 ): boolean {
@@ -22,7 +22,7 @@ export function Equal<K extends $.Comparable, V extends $.Comparable>(
 
 // EqualFunc is like Equal, but compares values using eq.
 // Keys are still compared with ==.
-export function EqualFunc<K extends $.Comparable, V1, V2>(
+export function EqualFunc<K extends $.Comparable | null, V1, V2>(
   m1: Map<K, V1>,
   m2: Map<K, V2>,
   eq: ((p0: V1, p1: V2) => boolean) | null,
@@ -40,7 +40,7 @@ export function EqualFunc<K extends $.Comparable, V1, V2>(
 }
 
 // clone returns a shallow copy of the map.
-export function clone<K extends $.Comparable, V>(
+export function clone<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): Map<K, V> | null {
   if (m == null) {
@@ -55,7 +55,7 @@ export function clone<K extends $.Comparable, V>(
 
 // Clone returns a copy of m.  This is a shallow clone:
 // the new keys and values are set using ordinary assignment.
-export function Clone<K extends $.Comparable, V>(
+export function Clone<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): Map<K, V> | null {
   // Preserve nil in case it matters.
@@ -69,7 +69,7 @@ export function Clone<K extends $.Comparable, V>(
 // When a key in src is already present in dst,
 // the value in dst will be overwritten by the value associated
 // with the key in src.
-export function Copy<K extends $.Comparable, V>(
+export function Copy<K extends $.Comparable | null, V>(
   dst: Map<K, V> | null,
   src: Map<K, V> | null,
 ): void {
@@ -79,7 +79,7 @@ export function Copy<K extends $.Comparable, V>(
 }
 
 // DeleteFunc deletes any key/value pairs from m for which del returns true.
-export function DeleteFunc<K extends $.Comparable, V>(
+export function DeleteFunc<K extends $.Comparable | null, V>(
   m: Map<K, V>,
   del: ((p0: K, p1: V) => boolean) | null,
 ): void {

package/gs/math/bits/index.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+
+import { Mul64 } from './index.js'
+
+describe('math/bits override', () => {
+  it('returns the full 128-bit product from Mul64', () => {
+    expect(Mul64(0xffffffffffffffffn, 0xffffffffffffffffn)).toEqual([
+      0xfffffffffffffffen,
+      1n,
+    ])
+    expect(Mul64(0x1fffffffffffffn, 0x1fffffffffffffn)).toEqual([
+      0x3ffffffffffn,
+      0xffc0000000000001n,
+    ])
+    expect(Mul64(0x1fffffffffffff, 0x1fffffffffffff)).toEqual([
+      0x3ffffffffff,
+      0xffc0000000000001n,
+    ])
+  })
+})

package/gs/math/bits/index.ts

@@ -17,7 +17,9 @@ function useBigIntResult(...values: Word64[]): boolean {
 }
 
 function word64Result(value: bigint, useBigInt: boolean): Word64 {
-  return useBigInt ? value : Number(value)
+  return useBigInt || value > BigInt(Number.MAX_SAFE_INTEGER) ?
+      value
+    : Number(value)
 }
 
 // --- Leading zeros ---
@@ -209,20 +211,16 @@ export function Reverse64(x: Word64): Word64 {
     ((word & 0x0000ffff0000ffffn) << 16n)
   // Swap 8-bit chunks
   word =
-    ((word & 0xff00ff00ff00ff00n) >> 8n) |
-    ((word & 0x00ff00ff00ff00ffn) << 8n)
+    ((word & 0xff00ff00ff00ff00n) >> 8n) | ((word & 0x00ff00ff00ff00ffn) << 8n)
   // Swap 4-bit chunks
   word =
-    ((word & 0xf0f0f0f0f0f0f0f0n) >> 4n) |
-    ((word & 0x0f0f0f0f0f0f0f0fn) << 4n)
+    ((word & 0xf0f0f0f0f0f0f0f0n) >> 4n) | ((word & 0x0f0f0f0f0f0f0f0fn) << 4n)
   // Swap 2-bit chunks
   word =
-    ((word & 0xccccccccccccccccn) >> 2n) |
-    ((word & 0x3333333333333333n) << 2n)
+    ((word & 0xccccccccccccccccn) >> 2n) | ((word & 0x3333333333333333n) << 2n)
   // Swap 1-bit chunks
   word =
-    ((word & 0xaaaaaaaaaaaaaaaan) >> 1n) |
-    ((word & 0x5555555555555555n) << 1n)
+    ((word & 0xaaaaaaaaaaaaaaaan) >> 1n) | ((word & 0x5555555555555555n) << 1n)
 
   return word64Result(word & uint64Mask, useBigInt)
 }
@@ -307,25 +305,14 @@ export function Mul64(x: Word64, y: Word64): [Word64, Word64] {
   const useBigInt = useBigIntResult(x, y)
   x = toUint64(x)
   y = toUint64(y)
-  const mask32 = 0xffffffffn
-
-  // Split into 32-bit parts
-  const x0 = x & mask32
-  const x1 = x >> 32n
-  const y0 = y & mask32
-  const y1 = y >> 32n
-
-  // Multiply parts
-  const p00 = x0 * y0
-  const p01 = x0 * y1
-  const p10 = x1 * y0
-  const p11 = x1 * y1
-
-  // Combine results
-  const lo = p00 + ((p01 + p10) << 32n)
-  const hi = p11 + ((p01 + p10) >> 32n) + (lo < p00 ? 1n : 0n)
-
-  return [word64Result(hi & uint64Mask, useBigInt), word64Result(lo & uint64Mask, useBigInt)]
+  const product = x * y
+  const lo = product & uint64Mask
+  const hi = product >> 64n
+
+  return [
+    word64Result(hi & uint64Mask, useBigInt),
+    word64Result(lo, useBigInt),
+  ]
 }
 
 // --- Division functions ---

package/gs/mime/index.ts

@@ -1,9 +1,15 @@
-export function FormatMediaType(t: string, param: Map<string, string> | Record<string, string> | null): string {
+export function FormatMediaType(
+  t: string,
+  param: Map<string, string> | Record<string, string> | null,
+): string {
   if (!isToken(t)) {
     return ''
   }
   let out = t
-  const entries = param instanceof Map ? Array.from(param.entries()) : Object.entries(param ?? {})
+  const entries =
+    param instanceof Map ?
+      Array.from(param.entries())
+    : Object.entries(param ?? {})
   entries.sort(([a], [b]) => a.localeCompare(b))
   for (const [key, value] of entries) {
     if (!isToken(key)) {