goscript 0.0.83 → 0.1.0

package/gs/fmt/fmt.test.ts

@@ -1,38 +1,49 @@
-import { describe, it, expect } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { resetHostRuntimeForTests } from '@goscript/builtin/hostio.js'
 import * as fmt from './fmt.js'
 
-// Helper to capture stdout via internal stdout.write
-// We will monkey-patch global process.stdout.write if available
+const originalDeno = (globalThis as any).Deno
+const originalProcess = (globalThis as any).process
+
+afterEach(() => {
+  if (originalDeno === undefined) {
+    delete (globalThis as any).Deno
+  } else {
+    ;(globalThis as any).Deno = originalDeno
+  }
+
+  if (originalProcess === undefined) {
+    delete (globalThis as any).process
+  } else {
+    ;(globalThis as any).process = originalProcess
+  }
+
+  resetHostRuntimeForTests()
+})
+
+// Helper to capture stdout via the hostio text output path.
 function captureStdout(run: () => void): string {
   let buf = ''
-  const hasProcess =
-    typeof process !== 'undefined' &&
-    (process as any).stdout &&
-    typeof (process as any).stdout.write === 'function'
-
-  if (hasProcess) {
-    const orig = (process as any).stdout.write
-    ;(process as any).stdout.write = (chunk: any) => {
-      buf += typeof chunk === 'string' ? chunk : String(chunk)
-      return true
-    }
-    try {
-      run()
-    } finally {
-      ;(process as any).stdout.write = orig
-    }
-  } else {
-    // Fallback: spy on console.log for environments without process
-    const origLog = console.log
-    ;(console as any).log = (msg: any) => {
-      buf += String(msg) + '\n'
-    }
-    try {
-      run()
-    } finally {
-      console.log = origLog
-    }
+  delete (globalThis as any).Deno
+  ;(globalThis as any).process = {
+    getBuiltinModule: vi.fn(() => ({
+      readSync: vi.fn(),
+      writeSync: vi.fn(
+        (
+          _fd: number,
+          chunk: Uint8Array,
+          _offset?: number,
+          length?: number,
+          _position?: number | null,
+        ) => {
+          buf += new TextDecoder().decode(chunk.subarray(0, length ?? chunk.length))
+          return length ?? chunk.length
+        },
+      ),
+    })),
   }
+  resetHostRuntimeForTests()
+  run()
 
   return buf
 }

package/gs/fmt/fmt.ts

@@ -3,6 +3,7 @@
 
 import * as $ from '@goscript/builtin/index.js'
 import * as errors from '@goscript/errors/index.js'
+import { writeHostStdoutText } from '@goscript/builtin/hostio.js'
 
 // Basic interfaces
 export interface Stringer {
@@ -259,28 +260,7 @@ function parseFormat(format: string, args: any[]): string {
 // Global stdout simulation for Print functions
 let stdout = {
   write: (data: string) => {
-    // Use process.stdout.write if available (Node.js), otherwise fallback to console.log
-    // but we need to avoid adding extra newlines that console.log adds
-    if (
-      typeof process !== 'undefined' &&
-      process.stdout &&
-      process.stdout.write
-    ) {
-      process.stdout.write(data)
-    } else {
-      // In browser environments, we need to use console.log but handle newlines carefully
-      // If the data already ends with \n, we should strip it to avoid double newlines
-      if (data.endsWith('\n')) {
-        console.log(data.slice(0, -1))
-      } else {
-        // Use console.log without adding newline by using a custom method
-        if (console.log) {
-          // For data without newlines, we can just print it directly
-          // This is a bit of a hack but works for most cases
-          console.log(data)
-        }
-      }
-    }
+    writeHostStdoutText(data)
   },
 }
 

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

@@ -4,6 +4,7 @@ import * as io from '@goscript/io/index.js'
 
 import { NewFile, Stderr, Stdin, Stdout } from './file_unix_js.gs.js'
 import { ErrClosed } from './error.gs.js'
+import { createHostFile, resetHostRuntimeForTests } from './types_js.gs.js'
 
 const originalDeno = (globalThis as any).Deno
 const originalProcess = (globalThis as any).process
@@ -20,6 +21,8 @@ afterEach(() => {
   } else {
     ;(globalThis as any).process = originalProcess
   }
+
+  resetHostRuntimeForTests()
 })
 
 describe('os stdio', () => {
@@ -45,6 +48,7 @@ describe('os stdio', () => {
       stdout: { writeSync: stdoutWriteSync },
     }
     delete (globalThis as any).process
+    resetHostRuntimeForTests()
 
     const input = NewFile(0, 'stdin')
     const output = NewFile(1, 'stdout')
@@ -93,6 +97,7 @@ describe('os stdio', () => {
         writeSync,
       })),
     }
+    resetHostRuntimeForTests()
 
     const input = NewFile(0, 'stdin')
     const output = NewFile(1, 'stdout')
@@ -110,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)
 
@@ -117,6 +172,7 @@ describe('os stdio', () => {
       stdin: { readSync: stdinReadSync },
     }
     delete (globalThis as any).process
+    resetHostRuntimeForTests()
 
     const input = NewFile(0, 'stdin')!
     const [readN, readErr] = input.Read(new Uint8Array(1))
@@ -128,4 +184,51 @@ describe('os stdio', () => {
     expect(closedN).toBe(0)
     expect(closedErr).toBe(ErrClosed)
   })
+
+  it('retries short writes until the full buffer is written', () => {
+    const writeSync = vi
+      .fn<(buffer: Uint8Array) => number>()
+      .mockImplementationOnce((_buffer: Uint8Array) => 2)
+      .mockImplementationOnce((buffer: Uint8Array) => buffer.length)
+
+    ;(globalThis as any).Deno = {
+      stdout: { writeSync },
+    }
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    const output = NewFile(1, 'stdout')!
+    const [writeN, writeErr] = output.Write(new Uint8Array([1, 2, 3, 4, 5]))
+    expect(writeN).toBe(5)
+    expect(writeErr).toBeNull()
+    expect(writeSync).toHaveBeenCalledTimes(2)
+    expect(Array.from(writeSync.mock.calls[1][0])).toEqual([3, 4, 5])
+  })
+
+  it('prefers direct handle read and write methods when available', () => {
+    const handle = {
+      readSync: vi.fn((buffer: Uint8Array) => {
+        buffer.set([11, 12, 13], 0)
+        return 3
+      }),
+      writeSync: vi
+        .fn<(buffer: Uint8Array) => number>()
+        .mockImplementationOnce((_buffer: Uint8Array) => 1)
+        .mockImplementationOnce((buffer: Uint8Array) => buffer.length),
+    }
+
+    const file = createHostFile('host-file', 99, handle)
+    const readBuf = new Uint8Array(4)
+
+    const [readN, readErr] = file.Read(readBuf)
+    expect(readN).toBe(3)
+    expect(readErr).toBeNull()
+    expect(Array.from(readBuf.slice(0, 3))).toEqual([11, 12, 13])
+
+    const [writeN, writeErr] = file.Write(new Uint8Array([21, 22, 23]))
+    expect(writeN).toBe(3)
+    expect(writeErr).toBeNull()
+    expect(handle.writeSync).toHaveBeenCalledTimes(2)
+    expect(Array.from(handle.writeSync.mock.calls[1][0])).toEqual([22, 23])
+  })
 })

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"
   ]
-} 
+}