goscript 0.1.1 → 0.1.3

package/gs/fmt/fmt.ts

@@ -408,11 +408,7 @@ export function Append(b: $.Bytes, ...a: any[]): $.Bytes {
   return newArray
 }
 
-export function Appendf(
-  b: $.Bytes,
-  format: string,
-  ...a: any[]
-): $.Bytes {
+export function Appendf(b: $.Bytes, format: string, ...a: any[]): $.Bytes {
   const result = parseFormat(format, a)
   const encoded = new TextEncoder().encode(result)
   const base = $.bytesToUint8Array(b)
@@ -492,12 +488,82 @@ export function Sscan(_str: string, ..._a: any[]): [number, $.GoError | null] {
 }
 
 export function Sscanf(
-  _str: string,
-  _format: string,
-  ..._a: any[]
+  str: string,
+  format: string,
+  ...a: any[]
 ): [number, $.GoError | null] {
-  // TODO: Implement formatted scanning from string
-  return [0, $.newError('Sscanf not implemented')]
+  const parts = buildScanPattern(format)
+  if (parts == null) {
+    return [0, $.newError(`unsupported Sscanf format: ${format}`)]
+  }
+  const match = parts.pattern.exec(str)
+  if (match == null) {
+    return [0, $.newError('input does not match format')]
+  }
+
+  let assigned = 0
+  for (let i = 0; i < parts.verbs.length && i < a.length; i++) {
+    const raw = match[i + 1]
+    const value = parts.verbs[i] === 'd' ? Number.parseInt(raw, 10) : raw
+    if (!assignScanValue(a[i], value)) {
+      return [assigned, $.newError('scan destination is not assignable')]
+    }
+    assigned++
+  }
+  return [assigned, null]
+}
+
+function buildScanPattern(
+  format: string,
+): { pattern: RegExp; verbs: string[] } | null {
+  let source = '^'
+  const verbs: string[] = []
+  for (let i = 0; i < format.length; i++) {
+    const ch = format[i]
+    if (ch !== '%') {
+      source += /\s/.test(ch) ? '\\s+' : escapeRegExp(ch)
+      continue
+    }
+    const verb = format[++i]
+    if (verb === '%') {
+      source += '%'
+      continue
+    }
+    if (verb === 'd') {
+      source += '([+-]?\\d+)'
+      verbs.push(verb)
+      continue
+    }
+    if (verb === 's') {
+      source += '(\\S+)'
+      verbs.push(verb)
+      continue
+    }
+    return null
+  }
+  source += '$'
+  return { pattern: new RegExp(source), verbs }
+}
+
+function assignScanValue(target: any, value: string | number): boolean {
+  const ref =
+    $.isVarRef(target) ? target
+    : (
+      target != null &&
+      typeof target === 'object' &&
+      $.isVarRef(target.__goValue)
+    ) ?
+      target.__goValue
+    : null
+  if (ref == null) {
+    return false
+  }
+  ref.value = value
+  return true
+}
+
+function escapeRegExp(ch: string): string {
+  return ch.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
 }
 
 export function Sscanln(

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

@@ -1,8 +1,11 @@
 import { describe, expect, it } from 'vitest'
 
+import * as $ from '../../../builtin/index.js'
 import {
   AppendVarint,
+  type CloneMessage,
   CompareEqualVT,
+  ConsumeVarint,
   DecodeFixed32,
   DecodeFixed64,
   DecodeVarint,
@@ -13,6 +16,7 @@ import {
   ErrIntOverflow,
   ErrInvalidLength,
   ErrUnexpectedEndOfGroup,
+  IsEqualVTSlice,
   SizeOfVarint,
   Skip,
 } from './index.js'
@@ -25,6 +29,30 @@ class TestValue {
   }
 }
 
+class TestCloneMessage implements CloneMessage {
+  SizeVT(): number {
+    return 0
+  }
+
+  MarshalToSizedBufferVT(): [$.Slice<number>, $.GoError] {
+    return [null, null]
+  }
+
+  MarshalVT(): [$.Slice<number>, $.GoError] {
+    return [null, null]
+  }
+
+  UnmarshalVT(): $.GoError {
+    return null
+  }
+
+  Reset(): void {}
+
+  CloneMessageVT(): CloneMessage | null {
+    return new TestCloneMessage()
+  }
+}
+
 describe('protobuf-go-lite EqualVT helpers', () => {
   it('accepts compiler-emitted runtime type arguments', () => {
     const equal = CompareEqualVT<TestValue>({
@@ -35,6 +63,31 @@ describe('protobuf-go-lite EqualVT helpers', () => {
     expect(equal(new TestValue('a'), new TestValue('b'))).toBe(false)
     expect(equal(null, null)).toBe(true)
   })
+
+  it('accepts nullable generated message slices', () => {
+    const left: $.Slice<TestValue | $.VarRef<TestValue> | null> = [
+      $.varRef(new TestValue('x')),
+      null,
+    ]
+    const right: $.Slice<TestValue | $.VarRef<TestValue> | null> = [
+      new TestValue('x'),
+      null,
+    ]
+
+    expect(IsEqualVTSlice(left, right)).toBe(true)
+  })
+})
+
+describe('protobuf-go-lite runtime interfaces', () => {
+  it('registers CloneMessage metadata for Go type assertions', () => {
+    const [value, ok] = $.typeAssertTuple<CloneMessage | null>(
+      new TestCloneMessage(),
+      'protobuf_go_lite.CloneMessage',
+    )
+
+    expect(ok).toBe(true)
+    expect(value?.CloneMessageVT()).toBeInstanceOf(TestCloneMessage)
+  })
 })
 
 describe('protobuf-go-lite wire helpers', () => {
@@ -50,9 +103,14 @@ describe('protobuf-go-lite wire helpers', () => {
     expect(DecodeVarintInt32(buf, offset)).toEqual([300, 4, null])
     expect(DecodeVarintInt64(buf, offset)).toEqual([300, 4, null])
     expect(DecodeVarintUint32(buf, offset)).toEqual([300, 4, null])
-    expect(Array.from(AppendVarint([], 300) as number[])).toEqual([
-      0xac,
-      0x02,
+    expect(Array.from(AppendVarint([], 300) as number[])).toEqual([0xac, 0x02])
+    expect(SizeOfVarint(0xffffffffffffffffn)).toBe(10)
+    expect(Array.from(AppendVarint([], 0xffffffffffffffffn) as number[])).toEqual([
+      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01,
+    ])
+    expect(ConsumeVarint(AppendVarint([], 0xffffffffffffffffn))).toEqual([
+      0xffffffffffffffffn,
+      10,
     ])
   })
 
@@ -80,10 +138,7 @@ describe('protobuf-go-lite wire helpers', () => {
       5,
       null,
     ])
-    expect(Skip(new Uint8Array([0x0c]))).toEqual([
-      0,
-      ErrUnexpectedEndOfGroup,
-    ])
+    expect(Skip(new Uint8Array([0x0c]))).toEqual([0, ErrUnexpectedEndOfGroup])
   })
 
   it('reports protobuf wire errors as Go errors', () => {

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

@@ -16,15 +16,37 @@ export interface Message {
   Reset(): void
 }
 
+$.registerInterfaceType('protobuf_go_lite.Message', null, [
+  { name: 'SizeVT', args: [], returns: [] },
+  { name: 'MarshalToSizedBufferVT', args: [], returns: [] },
+  { name: 'MarshalVT', args: [], returns: [] },
+  { name: 'UnmarshalVT', args: [], returns: [] },
+  { name: 'Reset', args: [], returns: [] },
+])
+
 export interface JSONMessage {
   MarshalJSON(): [$.Slice<number>, $.GoError]
   UnmarshalJSON(data: $.Slice<number>): $.GoError
 }
 
+$.registerInterfaceType('protobuf_go_lite.JSONMessage', null, [
+  { name: 'MarshalJSON', args: [], returns: [] },
+  { name: 'UnmarshalJSON', args: [], returns: [] },
+])
+
 export interface CloneMessage extends Message {
   CloneMessageVT(): CloneMessage | null
 }
 
+$.registerInterfaceType('protobuf_go_lite.CloneMessage', null, [
+  { name: 'SizeVT', args: [], returns: [] },
+  { name: 'MarshalToSizedBufferVT', args: [], returns: [] },
+  { name: 'MarshalVT', args: [], returns: [] },
+  { name: 'UnmarshalVT', args: [], returns: [] },
+  { name: 'Reset', args: [], returns: [] },
+  { name: 'CloneMessageVT', args: [], returns: [] },
+])
+
 export interface CloneVT<T> extends CloneMessage {
   CloneVT(): T
 }
@@ -37,37 +59,37 @@ export function CompareComparable<T>(): (t1: T, t2: T) => boolean {
   return (t1, t2) => t1 === t2
 }
 
-export function IsEqualVT<T extends EqualVT<T>>(
-  t1: T | null,
-  t2: T | null,
+export function IsEqualVT<T>(
+  t1: T | $.VarRef<T> | null,
+  t2: T | $.VarRef<T> | null,
 ): boolean
-export function IsEqualVT<T extends EqualVT<T>>(
+export function IsEqualVT<T>(
   _typeArgs: unknown,
-  t1: T | null,
-  t2: T | null,
+  t1: T | $.VarRef<T> | null,
+  t2: T | $.VarRef<T> | null,
 ): boolean
-export function IsEqualVT<T extends EqualVT<T>>(
+export function IsEqualVT<T>(
   arg0: unknown,
-  arg1: T | null,
-  arg2?: T | null,
+  arg1: T | $.VarRef<T> | null,
+  arg2?: T | $.VarRef<T> | null,
 ): boolean {
-  const t1 = arg2 === undefined ? (arg0 as T | null) : arg1
-  const t2 = arg2 === undefined ? arg1 : arg2
+  const t1 = $.pointerValueOrNil(arg2 === undefined ? (arg0 as T | $.VarRef<T> | null) : arg1)
+  const t2 = $.pointerValueOrNil(arg2 === undefined ? arg1 : arg2)
   if (t1 == null || t2 == null) {
     return t1 == t2
   }
-  return t1.EqualVT(t2)
+  return (t1 as unknown as EqualVT<T>).EqualVT(t2)
 }
 
-export function CompareEqualVT<T extends EqualVT<T>>(
+export function CompareEqualVT<T>(
   _typeArgs?: unknown,
-): (t1: T | null, t2: T | null) => boolean {
+): (t1: T | $.VarRef<T> | null, t2: T | $.VarRef<T> | null) => boolean {
   return (t1, t2) => IsEqualVT(t1, t2)
 }
 
-export function IsEqualVTSlice<T extends EqualVT<T>>(
-  s1: $.Slice<T>,
-  s2: $.Slice<T>,
+export function IsEqualVTSlice<T>(
+  s1: $.Slice<T | $.VarRef<T> | null>,
+  s2: $.Slice<T | $.VarRef<T> | null>,
 ): boolean {
   if ($.len(s1) !== $.len(s2)) {
     return false
@@ -83,58 +105,78 @@ export function IsEqualVTSlice<T extends EqualVT<T>>(
 export function EncodeVarint(
   dAtA: $.Slice<number>,
   offset: number,
-  v: number,
+  v: number | bigint,
 ): number {
   offset -= SizeOfVarint(v)
   const base = offset
-  while (v >= 0x80) {
-    setByte(dAtA, offset, (v % 0x80) | 0x80)
-    v = Math.floor(v / 0x80)
+  let value = normalizedVarint(v)
+  while (value >= 0x80n) {
+    setByte(dAtA, offset, Number((value & 0x7fn) | 0x80n))
+    value >>= 7n
     offset++
   }
-  setByte(dAtA, offset, v)
+  setByte(dAtA, offset, Number(value))
   return base
 }
 
-export function AppendVarint(b: $.Slice<number>, v: number): $.Slice<number> {
+export function AppendVarint(
+  b: $.Slice<number>,
+  v: number | bigint,
+): $.Slice<number> {
   const bytes: number[] = []
-  while (v >= 0x80) {
-    bytes.push((v % 0x80) | 0x80)
-    v = Math.floor(v / 0x80)
+  let value = normalizedVarint(v)
+  while (value >= 0x80n) {
+    bytes.push(Number((value & 0x7fn) | 0x80n))
+    value >>= 7n
   }
-  bytes.push(v)
+  bytes.push(Number(value))
   return $.append(b, ...bytes)
 }
 
 export function ConsumeVarint(b: $.Slice<number>): [number, number] {
-  let v = 0
-  let shift = 0
+  let v = 0n
+  let shift = 0n
   for (let i = 0; i < 10; i++) {
     if (i >= $.len(b)) {
       return [0, -1]
     }
     const value = byteSliceValue(b, i)
-    if (shift === 63 && value > 1) {
+    if (shift === 63n && value > 1) {
       return [0, -2]
     }
-    v += (value & 0x7f) * 2 ** shift
+    v += BigInt(value & 0x7f) << shift
     if (value < 0x80) {
-      return [v, i + 1]
+      return [varintResult(v), i + 1]
     }
-    shift += 7
+    shift += 7n
   }
   return [0, -2]
 }
 
-export function SizeOfVarint(x: number): number {
+export function SizeOfVarint(x: number | bigint): number {
+  let value = normalizedVarint(x)
   let n = 1
-  while (x >= 0x80) {
-    x = Math.floor(x / 0x80)
+  while (value >= 0x80n) {
+    value >>= 7n
     n++
   }
   return n
 }
 
+function normalizedVarint(value: number | bigint): bigint {
+  if (typeof value === 'bigint') {
+    return BigInt.asUintN(64, value)
+  }
+  return BigInt.asUintN(64, BigInt(Math.trunc(value)))
+}
+
+function varintResult(value: bigint): number {
+  if (value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+    return Number(value)
+  }
+  return value as unknown as number
+}
+
 export function DecodeVarint(
   b: $.Slice<number>,
   idx: number,

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

@@ -78,10 +78,11 @@ describe('protobuf-go-lite/json override', () => {
       a: new TestMessage('one', 1),
       b: new TestMessage('two', 2),
     })
-    const [sliceData, sliceErr] = MarshalSlice(undefined, DefaultMarshalerConfig, [
-      new TestMessage('one', 1),
-      new TestMessage('two', 2),
-    ])
+    const [sliceData, sliceErr] = MarshalSlice(
+      undefined,
+      DefaultMarshalerConfig,
+      [new TestMessage('one', 1), new TestMessage('two', 2)],
+    )
 
     expect(mapErr).toBeNull()
     expect(sliceErr).toBeNull()
@@ -99,7 +100,10 @@ describe('protobuf-go-lite/json override', () => {
       jsonBytes('{"name":"ok","count":"42"}'),
       msg,
     )
-    const state = NewUnmarshalState(jsonBytes('["Zm9vYg==","YXI="]'), DefaultUnmarshalerConfig)
+    const state = NewUnmarshalState(
+      jsonBytes('["Zm9vYg==","YXI="]'),
+      DefaultUnmarshalerConfig,
+    )
 
     expect(err).toBeNull()
     expect(msg).toEqual(new TestMessage('ok', 42))
@@ -120,7 +124,10 @@ describe('protobuf-go-lite/json override', () => {
 
   it('accepts raw wrapped values and object wrapped values', () => {
     const raw = NewUnmarshalState(jsonBytes('"abc"'), DefaultUnmarshalerConfig)
-    const object = NewUnmarshalState(jsonBytes('{"value": "def"}'), DefaultUnmarshalerConfig)
+    const object = NewUnmarshalState(
+      jsonBytes('{"value": "def"}'),
+      DefaultUnmarshalerConfig,
+    )
 
     expect(raw?.ReadWrappedString()).toBe('abc')
     expect(raw?.Err()).toBeNull()
@@ -129,13 +136,18 @@ describe('protobuf-go-lite/json override', () => {
   })
 
   it('reads and writes protobuf timestamp values as time.Time pointers', () => {
-    const state = NewUnmarshalState(jsonBytes('"2025-05-15T01:10:42Z"'), DefaultUnmarshalerConfig)
+    const state = NewUnmarshalState(
+      jsonBytes('"2025-05-15T01:10:42Z"'),
+      DefaultUnmarshalerConfig,
+    )
     const parsed = state?.ReadTime()
     const jsonStream = new JsonStream()
     const stream = new MarshalState({ stream: jsonStream })
 
     expect(state?.Err()).toBeNull()
-    expect($.pointerValue(parsed)?.Format(time.RFC3339)).toBe('2025-05-15T01:10:42Z')
+    expect($.pointerValue(parsed)?.Format(time.RFC3339)).toBe(
+      '2025-05-15T01:10:42Z',
+    )
 
     stream.WriteTime(parsed ?? null)
 
@@ -144,9 +156,18 @@ describe('protobuf-go-lite/json override', () => {
   })
 
   it('rejects invalid bool and numeric map keys', () => {
-    const boolState = NewUnmarshalState(jsonBytes('{"yes": 1}'), DefaultUnmarshalerConfig)
-    const intState = NewUnmarshalState(jsonBytes('{"1.5": 1}'), DefaultUnmarshalerConfig)
-    const uintState = NewUnmarshalState(jsonBytes('{"-1": 1}'), DefaultUnmarshalerConfig)
+    const boolState = NewUnmarshalState(
+      jsonBytes('{"yes": 1}'),
+      DefaultUnmarshalerConfig,
+    )
+    const intState = NewUnmarshalState(
+      jsonBytes('{"1.5": 1}'),
+      DefaultUnmarshalerConfig,
+    )
+    const uintState = NewUnmarshalState(
+      jsonBytes('{"-1": 1}'),
+      DefaultUnmarshalerConfig,
+    )
 
     boolState?.ReadBoolMap(() => {})
     intState?.ReadInt32Map(() => {})