goscript 0.1.0 → 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/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

@@ -5,9 +5,11 @@ 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'
 
@@ -47,4 +49,24 @@ describe('go/scanner override', () => {
 
     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

@@ -62,9 +62,49 @@ export class Error {
 }
 
 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
@@ -155,3 +195,10 @@ export function ErrorList_Error(list: ErrorList): string {
   }
   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

@@ -2,7 +2,24 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Position, Position_IsValid, Position_String } from './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', () => {
@@ -18,4 +35,33 @@ describe('go/token override', () => {
     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)
+  })
 })