goscript 0.0.84 → 0.1.0

package/gs/github.com/aperturerobotics/protobuf-go-lite/index.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { CompareEqualVT } from './index.js'
+
+class TestValue {
+  constructor(private readonly value: string) {}
+
+  EqualVT(other: TestValue): boolean {
+    return this.value == other.value
+  }
+}
+
+describe('protobuf-go-lite EqualVT helpers', () => {
+  it('accepts compiler-emitted runtime type arguments', () => {
+    const equal = CompareEqualVT<TestValue>({
+      T: { zero: () => null },
+    })
+
+    expect(equal(new TestValue('a'), new TestValue('a'))).toBe(true)
+    expect(equal(new TestValue('a'), new TestValue('b'))).toBe(false)
+    expect(equal(null, null)).toBe(true)
+  })
+})

package/gs/github.com/aperturerobotics/protobuf-go-lite/index.ts

@@ -9,6 +9,8 @@ export function IsEqualVT<T extends EqualVT<T>>(t1: T | null, t2: T | null): boo
   return t1.EqualVT(t2)
 }
 
-export function CompareEqualVT<T extends EqualVT<T>>(): (t1: T | null, t2: T | null) => boolean {
+export function CompareEqualVT<T extends EqualVT<T>>(
+  _typeArgs?: unknown,
+): (t1: T | null, t2: T | null) => boolean {
   return (t1, t2) => IsEqualVT(t1, t2)
 }

package/gs/github.com/aperturerobotics/wasivm/wazero/kernel/runtime/browser/meta.json

@@ -1,5 +1,7 @@
 {
-  "dependencies": [],
+  "dependencies": [
+    "github.com/aperturerobotics/wasivm/wazero/kernel/runtime"
+  ],
   "asyncMethods": {
     "Runtime.Compile": true,
     "Runtime.Close": true,

package/gs/go/scanner/index.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+import * as token from '@goscript/go/token/index.js'
+
+import {
+  ErrorList_Add,
+  ErrorList_Error,
+  ErrorList_Len,
+  ErrorList_RemoveMultiples,
+  type ErrorList,
+} from './index.js'
+
+describe('go/scanner override', () => {
+  it('adds and formats scanner errors', () => {
+    const list: $.VarRef<ErrorList> = $.varRef(null)
+
+    ErrorList_Add(
+      list,
+      $.markAsStructValue(
+        new token.Position({
+          Filename: 'test.go',
+          Line: 1,
+          Column: 1,
+        }),
+      ),
+      'test error',
+    )
+
+    expect(ErrorList_Len(list.value)).toBe(1)
+    expect(ErrorList_Error(list.value)).toBe('test.go:1:1: test error')
+  })
+
+  it('removes repeated line errors', () => {
+    const list: $.VarRef<ErrorList> = $.varRef(null)
+    const pos = $.markAsStructValue(
+      new token.Position({
+        Filename: 'test.go',
+        Line: 1,
+        Column: 1,
+      }),
+    )
+
+    ErrorList_Add(list, pos, 'first')
+    ErrorList_Add(list, pos, 'second')
+    ErrorList_RemoveMultiples(list)
+
+    expect(ErrorList_Len(list.value)).toBe(1)
+  })
+})

package/gs/go/scanner/index.ts

@@ -0,0 +1,157 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as token from '@goscript/go/token/index.js'
+
+export class Error {
+  public get Pos(): token.Position {
+    return this._fields.Pos.value
+  }
+
+  public set Pos(value: token.Position) {
+    this._fields.Pos.value = value
+  }
+
+  public get Msg(): string {
+    return this._fields.Msg.value
+  }
+
+  public set Msg(value: string) {
+    this._fields.Msg.value = value
+  }
+
+  public _fields: {
+    Pos: $.VarRef<token.Position>
+    Msg: $.VarRef<string>
+  }
+
+  constructor(init?: Partial<{ Pos: token.Position; Msg: string }>) {
+    this._fields = {
+      Pos: $.varRef(init?.Pos ?? new token.Position()),
+      Msg: $.varRef(init?.Msg ?? ''),
+    }
+  }
+
+  public clone(): Error {
+    return $.markAsStructValue(
+      new Error({
+        Pos: this.Pos.clone(),
+        Msg: this.Msg,
+      }),
+    )
+  }
+
+  public Error(): string {
+    return Error_Error(this)
+  }
+
+  static __typeInfo = $.registerStructType(
+    'go/scanner.Error',
+    new Error(),
+    [
+      {
+        name: 'Error',
+        args: [],
+        returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+      },
+    ],
+    Error,
+    {
+      Pos: { type: 'go/token.Position' },
+      Msg: { kind: $.TypeKind.Basic, name: 'string' },
+    },
+  )
+}
+
+export type ErrorList = $.Slice<Error | null>
+
+export const ScanComments = 1
+
+export function Error_Error(err: Error): string {
+  if (!err.Pos.IsValid()) {
+    return err.Msg
+  }
+  return `${err.Pos.String()}: ${err.Msg}`
+}
+
+export function ErrorList_Add(
+  list: $.VarRef<ErrorList>,
+  pos: token.Position,
+  msg: string,
+): void {
+  list.value = $.append(
+    list.value,
+    $.markAsStructValue(new Error({ Pos: pos, Msg: msg })),
+  )
+}
+
+export function ErrorList_Len(list: ErrorList): number {
+  return $.len(list)
+}
+
+export function ErrorList_Less(list: ErrorList, i: number, j: number): boolean {
+  const left = list![i]!
+  const right = list![j]!
+  if (left.Pos.Filename !== right.Pos.Filename) {
+    return left.Pos.Filename < right.Pos.Filename
+  }
+  if (left.Pos.Line !== right.Pos.Line) {
+    return left.Pos.Line < right.Pos.Line
+  }
+  if (left.Pos.Column !== right.Pos.Column) {
+    return left.Pos.Column < right.Pos.Column
+  }
+  return left.Msg < right.Msg
+}
+
+export function ErrorList_Swap(list: ErrorList, i: number, j: number): void {
+  const first = list![i]
+  list![i] = list![j]
+  list![j] = first
+}
+
+export function ErrorList_Sort(list: ErrorList): void {
+  list?.sort((left, right) => {
+    if (left === null || right === null) {
+      if (left === right) {
+        return 0
+      }
+      if (left === null) {
+        return -1
+      }
+      return 1
+    }
+    if (ErrorList_Less([left, right], 0, 1)) {
+      return -1
+    }
+    if (ErrorList_Less([right, left], 0, 1)) {
+      return 1
+    }
+    return 0
+  })
+}
+
+export function ErrorList_RemoveMultiples(list: $.VarRef<ErrorList>): void {
+  ErrorList_Sort(list.value)
+  const seen = new Set<string>()
+  list.value = $.asArray(list.value).filter((err) => {
+    if (err === null) {
+      return false
+    }
+    const key = `${err.Pos.Filename}:${err.Pos.Line}`
+    if (seen.has(key)) {
+      return false
+    }
+    seen.add(key)
+    return true
+  })
+}
+
+export function ErrorList_Error(list: ErrorList): string {
+  const errors = $.asArray(list).filter((err) => err !== null)
+  if (errors.length === 0) {
+    return 'no errors'
+  }
+  if (errors.length === 1) {
+    return errors[0]!.Error()
+  }
+  return `${errors[0]!.Error()} (and ${errors.length - 1} more errors)`
+}

package/gs/go/token/index.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { Position, Position_IsValid, Position_String } from './index.js'
+
+describe('go/token override', () => {
+  it('models Position values', () => {
+    const pos = $.markAsStructValue(
+      new Position({
+        Filename: 'test.go',
+        Line: 3,
+        Column: 9,
+      }),
+    )
+
+    expect(Position_IsValid(pos)).toBe(true)
+    expect(Position_String(pos)).toBe('test.go:3:9')
+    expect(pos.clone().String()).toBe('test.go:3:9')
+  })
+})

package/gs/go/token/index.ts

@@ -0,0 +1,120 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export type Pos = number
+
+export const NoPos: Pos = 0
+
+export class Position {
+  public get Filename(): string {
+    return this._fields.Filename.value
+  }
+
+  public set Filename(value: string) {
+    this._fields.Filename.value = value
+  }
+
+  public get Offset(): number {
+    return this._fields.Offset.value
+  }
+
+  public set Offset(value: number) {
+    this._fields.Offset.value = value
+  }
+
+  public get Line(): number {
+    return this._fields.Line.value
+  }
+
+  public set Line(value: number) {
+    this._fields.Line.value = value
+  }
+
+  public get Column(): number {
+    return this._fields.Column.value
+  }
+
+  public set Column(value: number) {
+    this._fields.Column.value = value
+  }
+
+  public _fields: {
+    Filename: $.VarRef<string>
+    Offset: $.VarRef<number>
+    Line: $.VarRef<number>
+    Column: $.VarRef<number>
+  }
+
+  constructor(
+    init?: Partial<{
+      Filename: string
+      Offset: number
+      Line: number
+      Column: number
+    }>,
+  ) {
+    this._fields = {
+      Filename: $.varRef(init?.Filename ?? ''),
+      Offset: $.varRef(init?.Offset ?? 0),
+      Line: $.varRef(init?.Line ?? 0),
+      Column: $.varRef(init?.Column ?? 0),
+    }
+  }
+
+  public clone(): Position {
+    return $.markAsStructValue(
+      new Position({
+        Filename: this.Filename,
+        Offset: this.Offset,
+        Line: this.Line,
+        Column: this.Column,
+      }),
+    )
+  }
+
+  public IsValid(): boolean {
+    return Position_IsValid(this)
+  }
+
+  public String(): string {
+    return Position_String(this)
+  }
+
+  static __typeInfo = $.registerStructType(
+    'go/token.Position',
+    new Position(),
+    [
+      {
+        name: 'IsValid',
+        args: [],
+        returns: [{ type: { kind: $.TypeKind.Basic, name: 'bool' } }],
+      },
+      {
+        name: 'String',
+        args: [],
+        returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+      },
+    ],
+    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' },
+    },
+  )
+}
+
+export function Position_IsValid(pos: Position): boolean {
+  return pos.Line > 0
+}
+
+export function Position_String(pos: Position): string {
+  if (!Position_IsValid(pos)) {
+    return '-'
+  }
+  const filename = pos.Filename === '' ? '<input>' : pos.Filename
+  if (pos.Column > 0) {
+    return `${filename}:${pos.Line}:${pos.Column}`
+  }
+  return `${filename}:${pos.Line}`
+}

package/gs/os/file_unix_js.test.ts

@@ -115,6 +115,56 @@ describe('os stdio', () => {
     expect(writeSync).toHaveBeenCalledTimes(1)
   })
 
+  it('falls back to process builtin fs when Deno lacks sync stdio', () => {
+    const readSync = vi.fn(
+      (
+        _fd: number,
+        buffer: Uint8Array,
+        _offset?: number,
+        _length?: number,
+        _position?: number | null,
+      ) => {
+        buffer.set([5, 6], 0)
+        return 2
+      },
+    )
+    const writeSync = vi.fn(
+      (
+        _fd: number,
+        _buffer: Uint8Array,
+        _offset?: number,
+        length?: number,
+        _position?: number | null,
+      ) => length ?? 0,
+    )
+
+    ;(globalThis as any).Deno = {
+      stdin: {},
+      stdout: {},
+    }
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync,
+        writeSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    const input = NewFile(0, 'stdin')
+    const output = NewFile(1, 'stdout')
+    const readBuf = new Uint8Array(2)
+
+    const [readN, readErr] = input!.Read(readBuf)
+    expect(readN).toBe(2)
+    expect(readErr).toBeNull()
+    expect(Array.from(readBuf)).toEqual([5, 6])
+
+    const [writeN, writeErr] = output!.Write(new Uint8Array([7, 8, 9]))
+    expect(writeN).toBe(3)
+    expect(writeErr).toBeNull()
+    expect(writeSync).toHaveBeenCalledTimes(1)
+  })
+
   it('returns EOF on zero-byte reads and ErrClosed after Close', () => {
     const stdinReadSync = vi.fn(() => 0)
 

package/gs/os/meta.json

@@ -3,7 +3,6 @@
     "errors",
     "internal/byteorder",
     "internal/goarch",
-    "internal/poll",
     "io",
     "io/fs",
     "runtime",
@@ -12,4 +11,4 @@
     "time",
     "unsafe"
   ]
-} 
+}

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

@@ -0,0 +1,85 @@
+import { basename, join } from 'node:path'
+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'
+
+const tempRoots: string[] = []
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  vi.unstubAllGlobals()
+  for (const root of tempRoots.splice(0)) {
+    rmSync(root, { force: true, recursive: true })
+  }
+})
+
+function makeTempRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), 'goscript-os-temp-'))
+  tempRoots.push(root)
+  return root
+}
+
+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
+    }),
+  })
+}
+
+function forbidMathRandom(): void {
+  vi.spyOn(Math, 'random').mockImplementation(() => {
+    throw new Error('os temp names must not use Math.random')
+  })
+}
+
+describe('os temp files', () => {
+  it('uses Web Crypto bytes for temp names', () => {
+    const root = makeTempRoot()
+    stubRandomBytes([0x78, 0x56, 0x34, 0x12])
+    forbidMathRandom()
+
+    const [dir, dirErr] = MkdirTemp(root, 'dir-*.tmp')
+    expect(dirErr).toBeNull()
+    expect(basename(dir)).toBe('dir-305419896.tmp')
+    expect(existsSync(dir)).toBe(true)
+
+    const [file, fileErr] = CreateTemp(root, 'file-*.tmp')
+    expect(fileErr).toBeNull()
+    expect(file).not.toBeNull()
+    expect(basename(file!.Name())).toBe('file-305419896.tmp')
+    expect(existsSync(file!.Name())).toBe(true)
+    file!.Close()
+  })
+
+  it('does not truncate an existing path after a random collision', () => {
+    const root = makeTempRoot()
+    const existing = join(root, 'file-305419896.tmp')
+    writeFileSync(existing, 'keep')
+    stubRandomBytes([0x78, 0x56, 0x34, 0x12])
+    forbidMathRandom()
+
+    const [file, err] = CreateTemp(root, 'file-*.tmp')
+
+    expect(file).toBeNull()
+    expect(err).not.toBeNull()
+    expect(readFileSync(existing, 'utf8')).toBe('keep')
+  })
+
+  it('reports ErrUnimplemented without a secure random source', () => {
+    const root = makeTempRoot()
+    vi.stubGlobal('crypto', {})
+    forbidMathRandom()
+
+    const [dir, err] = MkdirTemp(root, 'dir-*')
+
+    expect(dir).toBe('')
+    expect(err).toBe(ErrUnimplemented)
+  })
+})

package/gs/os/tempfile.gs.ts

@@ -1,8 +1,8 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
 import { TempDir } from "./file_constants_js.gs.js";
-import { Create, Mkdir } from "./file_js.gs.js";
-import { File } from "./types_js.gs.js";
+import { Mkdir } from "./file_js.gs.js";
+import { createHostFile, File, getDeno, getNodeFS, newHostError } from "./types_js.gs.js";
 
 export function joinPath(dir: string, file: string): string {
   if (dir === "" || dir === ".") {
@@ -20,33 +20,93 @@ export function joinPath(dir: string, file: string): string {
   return dir + "/" + file
 }
 
-function nextTempPath(dir: string, pattern: string): string {
+function nextTempPath(dir: string, pattern: string): [string, $.GoError] {
   const baseDir = dir === "" ? TempDir() : dir
-  const suffix = Math.random().toString(36).slice(2, 10) + Date.now().toString(36)
-  const name = pattern.includes("*") ? pattern.replace("*", suffix) : pattern + suffix
-  return joinPath(baseDir, name)
+  const [suffix, err] = nextRandom()
+  if (err !== null) {
+    return ["", err]
+  }
+  const star = pattern.lastIndexOf("*")
+  const name =
+    star >= 0
+      ? pattern.slice(0, star) + suffix + pattern.slice(star + 1)
+      : pattern + suffix
+  return [joinPath(baseDir, name), null]
+}
+
+function nextRandom(): [string, $.GoError] {
+  const crypto = globalThis.crypto
+  if (!crypto || typeof crypto.getRandomValues !== "function") {
+    return ["", ErrUnimplemented]
+  }
+  const bytes = new Uint8Array(4)
+  crypto.getRandomValues(bytes)
+  const value =
+    bytes[0] |
+    (bytes[1] << 8) |
+    (bytes[2] << 16) |
+    (bytes[3] << 24)
+  return [(value >>> 0).toString(10), null]
+}
+
+function createTempFile(path: string): [File | null, $.GoError] {
+  const denoObj = getDeno()
+  if (denoObj?.openSync) {
+    try {
+      const handle = denoObj.openSync(path, {
+        createNew: true,
+        mode: 0o600,
+        read: true,
+        write: true,
+      })
+      return [createHostFile(path, handle?.rid ?? -1, handle), null]
+    } catch (err) {
+      return [null, newHostError(err)]
+    }
+  }
+
+  const nodeFS = getNodeFS()
+  if (nodeFS?.openSync) {
+    try {
+      return [createHostFile(path, nodeFS.openSync(path, "wx+", 0o600)), null]
+    } catch (err) {
+      return [null, newHostError(err)]
+    }
+  }
+
+  return [null, ErrUnimplemented]
 }
 
 export function CreateTemp(dir: string, pattern: string): [File | null, $.GoError] {
   const template = pattern === "" ? "tmp-*" : pattern
+  let lastErr: $.GoError = ErrUnimplemented
   for (let i = 0; i < 16; i++) {
-    const path = nextTempPath(dir, template)
-    const [file, err] = Create(path)
+    const [path, randErr] = nextTempPath(dir, template)
+    if (randErr !== null) {
+      return [null, randErr]
+    }
+    const [file, err] = createTempFile(path)
     if (err === null) {
       return [file, null]
     }
+    lastErr = err
   }
-  return [null, ErrUnimplemented]
+  return [null, lastErr]
 }
 
 export function MkdirTemp(dir: string, pattern: string): [string, $.GoError] {
   const template = pattern === "" ? "tmp-*" : pattern
+  let lastErr: $.GoError = ErrUnimplemented
   for (let i = 0; i < 16; i++) {
-    const path = nextTempPath(dir, template)
+    const [path, randErr] = nextTempPath(dir, template)
+    if (randErr !== null) {
+      return ["", randErr]
+    }
     const err = Mkdir(path, 0o700)
     if (err === null) {
       return [path, null]
     }
+    lastErr = err
   }
-  return ["", ErrUnimplemented]
+  return ["", lastErr]
 }