goscript 0.0.84 → 0.1.1

package/gs/github.com/aperturerobotics/starpc/srpc/meta.json

@@ -0,0 +1,40 @@
+{
+  "dependencies": [
+    "context",
+    "errors",
+    "io",
+    "github.com/aperturerobotics/protobuf-go-lite"
+  ],
+  "asyncMethods": {
+    "Client.ExecCall": true,
+    "Client.NewStream": true,
+    "ClientSet.ExecCall": true,
+    "ClientSet.NewStream": true,
+    "PrefixClient.ExecCall": true,
+    "PrefixClient.NewStream": true,
+    "Stream.MsgSend": true,
+    "Stream.MsgRecv": true,
+    "Stream.CloseSend": true,
+    "Stream.Close": true,
+    "StreamRecv.MsgRecv": true,
+    "StreamRecv.CloseSend": true,
+    "StreamRecv.Close": true,
+    "StreamRecv.Recv": true,
+    "StreamRecv.RecvTo": true,
+    "StreamSend.MsgSend": true,
+    "StreamSend.CloseSend": true,
+    "StreamSend.Close": true,
+    "StreamSend.Send": true,
+    "StreamSendAndClose.MsgSend": true,
+    "StreamSendAndClose.CloseSend": true,
+    "StreamSendAndClose.Close": true,
+    "StreamSendAndClose.Send": true,
+    "StreamSendAndClose.SendAndClose": true,
+    "InvokerFunc.InvokeMethod": true,
+    "InvokerSlice.InvokeMethod": true,
+    "Invoker.InvokeMethod": true,
+    "PrefixInvoker.InvokeMethod": true,
+    "Handler.InvokeMethod": true,
+    "Mux.InvokeMethod": true
+  }
+}

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/github.com/klauspost/compress/internal/le/index.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+
+import { arrayToSlice } from '@goscript/builtin/index.js'
+import { TrailingZeros64 } from '@goscript/math/bits/index.js'
+
+import { Load32, Load64, Store64 } from './index.js'
+
+function bytes(value: string): number[] {
+  return Array.from(value, (char) => char.charCodeAt(0))
+}
+
+function matchBytes(a: number[], b: number[]): number {
+  const diff = (Load64(undefined, arrayToSlice(a), 0) as unknown as bigint) ^
+    (Load64(undefined, arrayToSlice(b), 0) as unknown as bigint)
+  return TrailingZeros64(diff) >> 3
+}
+
+describe('klauspost internal le override', () => {
+  it('loads 32-bit little-endian values as unsigned numbers', () => {
+    expect(Load32(undefined, arrayToSlice([0x78, 0x78, 0x78, 0x78]), 0)).toBe(
+      2021161080,
+    )
+  })
+
+  it('keeps high-byte 64-bit differences exact for S2 match length', () => {
+    const base = bytes('xxxxxxxx')
+    expect(matchBytes(base, bytes('yxxxxxxx'))).toBe(0)
+    expect(matchBytes(base, bytes('xxxxyxxx'))).toBe(4)
+  })
+
+  it('stores 64-bit little-endian values at the requested offset', () => {
+    const out = arrayToSlice<number>([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    Store64(undefined, out, 1, 0x0102030405060708n)
+    expect(Array.from(out!)).toEqual([0, 8, 7, 6, 5, 4, 3, 2, 1, 0])
+  })
+})

package/gs/github.com/klauspost/compress/internal/le/index.ts

@@ -0,0 +1,114 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export type Indexer = number
+
+function index(value: unknown): number {
+  return Number(value)
+}
+
+function byteAt(b: $.Slice<number>, i: number): number {
+  return b![i] ?? 0
+}
+
+function isSlice(value: unknown): value is $.Slice<number> {
+  return (
+    Array.isArray(value) ||
+    value === null ||
+    value instanceof Uint8Array ||
+    (typeof value === 'object' && value !== undefined && '__meta__' in value)
+  )
+}
+
+function loadArgs(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): [$.Slice<number>, number] {
+  if (isSlice(typeArgsOrB)) {
+    return [typeArgsOrB, index(bOrI)]
+  }
+  return [bOrI as $.Slice<number>, index(i)]
+}
+
+export function Load8(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): number {
+  const [b, off] = loadArgs(typeArgsOrB, bOrI, i)
+  return byteAt(b, off)
+}
+
+export function Load16(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): number {
+  const [b, off] = loadArgs(typeArgsOrB, bOrI, i)
+  return byteAt(b, off) | (byteAt(b, off + 1) << 8)
+}
+
+export function Load32(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): number {
+  const [b, off] = loadArgs(typeArgsOrB, bOrI, i)
+  return (
+    byteAt(b, off) |
+    (byteAt(b, off + 1) << 8) |
+    (byteAt(b, off + 2) << 16) |
+    (byteAt(b, off + 3) << 24)
+  ) >>> 0
+}
+
+export function Load64(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  i?: unknown,
+): number {
+  const [b, off] = loadArgs(typeArgsOrB, bOrI, i)
+  const value =
+    BigInt(byteAt(b, off)) |
+    (BigInt(byteAt(b, off + 1)) << 8n) |
+    (BigInt(byteAt(b, off + 2)) << 16n) |
+    (BigInt(byteAt(b, off + 3)) << 24n) |
+    (BigInt(byteAt(b, off + 4)) << 32n) |
+    (BigInt(byteAt(b, off + 5)) << 40n) |
+    (BigInt(byteAt(b, off + 6)) << 48n) |
+    (BigInt(byteAt(b, off + 7)) << 56n)
+  return value as unknown as number
+}
+
+export function Store16(b: $.Slice<number>, v: number): void {
+  b![0] = v & 0xff
+  b![1] = (v >> 8) & 0xff
+}
+
+export function Store32(b: $.Slice<number>, v: number): void {
+  b![0] = v & 0xff
+  b![1] = (v >> 8) & 0xff
+  b![2] = (v >> 16) & 0xff
+  b![3] = (v >> 24) & 0xff
+}
+
+export function Store64(
+  typeArgsOrB: $.GenericTypeArgs | $.Slice<number> | undefined,
+  bOrI?: $.Slice<number> | unknown,
+  iOrV?: unknown,
+  maybeV?: number | bigint,
+): void {
+  const genericCall = !isSlice(typeArgsOrB)
+  const b = (genericCall ? bOrI : typeArgsOrB) as $.Slice<number>
+  const off = genericCall ? index(iOrV) : index(bOrI)
+  const v = genericCall ? maybeV : iOrV
+  const value = BigInt(v as number | bigint) & ((1n << 64n) - 1n)
+  b![off] = Number(value & 0xffn)
+  b![off + 1] = Number((value >> 8n) & 0xffn)
+  b![off + 2] = Number((value >> 16n) & 0xffn)
+  b![off + 3] = Number((value >> 24n) & 0xffn)
+  b![off + 4] = Number((value >> 32n) & 0xffn)
+  b![off + 5] = Number((value >> 40n) & 0xffn)
+  b![off + 6] = Number((value >> 48n) & 0xffn)
+  b![off + 7] = Number((value >> 56n) & 0xffn)
+}

package/gs/go/internal/scannerhooks/index.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest'
+
+import { StringEnd, __goscript_set_StringEnd } from './index.js'
+
+describe('go/internal/scannerhooks override', () => {
+  it('stores a synchronous StringEnd hook', () => {
+    __goscript_set_StringEnd(() => 12)
+
+    expect(StringEnd?.({})).toBe(12)
+
+    __goscript_set_StringEnd(null)
+    expect(StringEnd).toBeNull()
+  })
+})

package/gs/go/internal/scannerhooks/index.ts

@@ -0,0 +1,9 @@
+import type * as token from '@goscript/go/token/index.js'
+
+export let StringEnd: ((scanner: any) => token.Pos) | null = null
+
+export function __goscript_set_StringEnd(
+  value: ((scanner: any) => token.Pos) | null,
+): void {
+  StringEnd = value
+}

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

@@ -0,0 +1,72 @@
+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_Err,
+  ErrorList_Error,
+  ErrorList_Len,
+  ErrorList_RemoveMultiples,
+  Scanner,
+  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)
+  })
+
+  it('returns nil Err for an empty list and an error for non-empty lists', () => {
+    const empty: ErrorList = null
+    expect(ErrorList_Err(empty)).toBeNull()
+
+    const list: $.VarRef<ErrorList> = $.varRef(null)
+    ErrorList_Add(list, new token.Position({ Line: 1 }), 'first')
+    expect(ErrorList_Err(list.value)?.Error()).toBe('1: first')
+  })
+
+  it('provides a Scanner surface for generated go/parser code', () => {
+    const fset = token.NewFileSet()
+    const file = fset.AddFile('test.go', -1, 0)
+    const scanner = new Scanner()
+
+    scanner.Init(file, null, null, 0)
+
+    expect(scanner.Scan()).toEqual([file.Pos(0), token.EOF, ''])
+    expect(scanner.Scan()).toEqual([file.Pos(0), token.EOF, ''])
+  })
+})

package/gs/go/scanner/index.ts

@@ -0,0 +1,204 @@
+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 type ErrorHandler = (pos: token.Position, msg: string) => void
+export type Mode = number
+
+export const ScanComments = 1
+
+export class Scanner {
+  public ErrorCount = 0
+  private file: token.File | null = null
+  private src: $.Slice<number> = null
+  private err: ErrorHandler | null = null
+  private done = false
+
+  public clone(): Scanner {
+    const scanner = new Scanner()
+    scanner.ErrorCount = this.ErrorCount
+    scanner.file = this.file
+    scanner.src = this.src
+    scanner.err = this.err
+    scanner.done = this.done
+    return scanner
+  }
+
+  public Init(
+    file: token.File | $.VarRef<token.File> | null,
+    src: $.Slice<number>,
+    err: ErrorHandler | null,
+    _mode: Mode,
+  ): void {
+    this.file = file === null ? null : $.pointerValue<token.File>(file)
+    this.src = src
+    this.err = err
+    this.done = false
+  }
+
+  public Scan(): [token.Pos, token.Token, string] {
+    if (this.done) {
+      return [this.file?.Pos($.len(this.src)) ?? token.NoPos, token.EOF, '']
+    }
+    this.done = true
+    return [this.file?.Pos(0) ?? token.NoPos, token.EOF, '']
+  }
+}
+
+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)`
+}
+
+export function ErrorList_Err(list: ErrorList): $.GoError {
+  if ($.len(list) === 0) {
+    return null
+  }
+  return $.newError(ErrorList_Error(list))
+}

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

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import {
+  ADD,
+  COMMENT,
+  FileSet,
+  IDENT,
+  IF,
+  IsIdentifier,
+  IsKeyword,
+  Lookup,
+  NewFileSet,
+  Position,
+  Position_IsValid,
+  Position_String,
+  Token_IsKeyword,
+  Token_IsLiteral,
+  Token_Precedence,
+  Token_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')
+  })
+
+  it('exports Go token constants and predicates', () => {
+    expect(Token_String(ADD)).toBe('+')
+    expect(Token_String(COMMENT)).toBe('COMMENT')
+    expect(Token_Precedence(ADD)).toBe(4)
+    expect(Token_IsLiteral(IDENT)).toBe(true)
+    expect(Token_IsKeyword(IF)).toBe(true)
+    expect(Lookup('if')).toBe(IF)
+    expect(Lookup('value')).toBe(IDENT)
+    expect(IsKeyword('func')).toBe(true)
+    expect(IsIdentifier('value42')).toBe(true)
+    expect(IsIdentifier('func')).toBe(false)
+  })
+
+  it('tracks files and source positions', () => {
+    const fset = NewFileSet()
+    expect(fset).toBeInstanceOf(FileSet)
+
+    const file = fset.AddFile('test.go', -1, 12)
+    file.SetLinesForContent($.stringToBytes('one\ntwo\nthree'))
+    file.AddLineColumnInfo(4, 'other.go', 20, 3)
+
+    const pos = file.Pos(5)
+    expect(file.Offset(pos)).toBe(5)
+    expect(file.Line(pos)).toBe(20)
+    expect(Position_String(file.Position(pos))).toBe('other.go:20:4')
+    expect(Position_String(fset.Position(pos))).toBe('other.go:20:4')
+    expect(fset.File(pos)).toBe(file)
+  })
+})