goscript 0.1.1 → 0.1.3

package/gs/builtin/runtime-contract.test.ts

@@ -1,9 +1,12 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import {
+  append,
   bytesToUint8Array,
+  type Bytes,
   byte,
   cap,
+  cloneArrayValue,
   cloneStructValue,
   callGenericMethod,
   chanRecvWithOk,
@@ -11,6 +14,7 @@ import {
   genericZero,
   goSlice,
   int,
+  arrayPointerFromIndexRef,
   indexAddress,
   indexRef,
   interfaceValue,
@@ -22,6 +26,7 @@ import {
   mapSet,
   markAsStructValue,
   namedFunction,
+  namedValueInterfaceValue,
   newError,
   pointerValue,
   print,
@@ -30,13 +35,19 @@ import {
   registerInterfaceType,
   registerStructType,
   resetHostRuntimeForTests,
+  selectStatement,
   sliceToArray,
+  sliceHeaderRef,
+  stringHeaderRef,
   TypeKind,
   typeAssert,
+  typeAssertTuple,
   typedNil,
   uint,
   uint64Add,
   uint64And,
+  uint64Div,
+  uint64Mod,
   uint64Mul,
   uint64Or,
   uint64Shl,
@@ -112,11 +123,17 @@ describe('builtin runtime contract helpers', () => {
   it('exposes numeric, varref, map, and error helpers', () => {
     expect(int(1.9)).toBe(1)
     expect(int(3n)).toBe(3)
+    expect(uint(257, 8)).toBe(1)
+    expect(uint(-1.9, 8)).toBe(255)
+    expect(uint(0x1_0000_0005, 32)).toBe(5)
+    expect(uint(42, 64)).toBe(42)
     expect(uint(-1n, 8)).toBe(255)
     expect(byte(257)).toBe(1)
     expect(uint(uint64Shl(1n, 63), 32)).toBe(0)
     expect(uint(uint64Shr(uint64Shl(1n, 63), 60), 32)).toBe(8)
     expect(uint(uint64Mul(0xffffffffffffffffn, 3), 32)).toBe(0xfffffffd)
+    expect(uint64Div(0xffffffffffffffffn, 4114)).toBe(4483895010624587)
+    expect(uint64Mod(0xffffffffffffffffn, 4114)).toBe(697)
     expect(uint(uint64Add(0xffffffffffffffffn, 2), 32)).toBe(1)
     expect(uint(uint64Sub(1n, 2), 32)).toBe(0xffffffff)
     expect(uint(uint64And(0xf0n, 0x3cn), 32)).toBe(0x30)
@@ -147,12 +164,49 @@ describe('builtin runtime contract helpers', () => {
       }),
     ).toEqual({ value: nilNamedSlice, ok: true })
     expect(pointerValue({ ok: true })).toEqual({ ok: true })
+    const namedPointerBox = namedValueInterfaceValue(
+      varRef(new Uint8Array([1, 2])),
+      '*main.Bytes',
+      {},
+    )
+    expect(pointerValue(namedPointerBox)).toEqual(new Uint8Array([1, 2]))
+    const namedPointerMethodBox = namedValueInterfaceValue(
+      varRef(new Uint8Array([1, 2, 3])),
+      '*main.Bytes',
+      { Len: (receiver: any) => len(receiver.value) },
+    )
+    expect(pointerValue(namedPointerMethodBox)).toBe(namedPointerMethodBox)
+    expect(pointerValue(namedPointerMethodBox).Len()).toBe(3)
+    expect(len(pointerValue(namedPointerMethodBox))).toBe(3)
+    expect(bytesToUint8Array(pointerValue(namedPointerMethodBox))).toEqual(
+      new Uint8Array([1, 2, 3]),
+    )
+    expect(bytesToUint8Array(goSlice(pointerValue(namedPointerMethodBox), 1))).toEqual(
+      new Uint8Array([2, 3]),
+    )
+    const namedStringBox = namedValueInterfaceValue('id', 'main.Name', {
+      String: (receiver: string) => `name:${receiver}`,
+    })
+    expect(pointerValue(namedStringBox)).toBe(namedStringBox)
+    expect(pointerValue(namedStringBox).String()).toBe('name:id')
     expect(cloneStructValue({ clone: () => ({ ok: true }) })).toEqual({
       ok: true,
     })
     expect(
       cloneStructValue({ __goscriptClone: () => ({ internal: true }) }),
     ).toEqual({ internal: true })
+    const fixedBytes = new Uint8Array([1, 2, 3])
+    const clonedBytes = cloneArrayValue(fixedBytes)
+    expect(clonedBytes).toEqual(fixedBytes)
+    expect(clonedBytes).not.toBe(fixedBytes)
+    const fixedWords = [
+      [1, 2],
+      [3, 4],
+    ]
+    const clonedWords = cloneArrayValue(fixedWords)
+    expect(clonedWords).toEqual(fixedWords)
+    expect(clonedWords).not.toBe(fixedWords)
+    expect(clonedWords[0]).not.toBe(fixedWords[0])
     expect(() => pointerValue(null)).toThrow('nil pointer dereference')
     const unsupported = unsupportedPointerRef<number>(0)
     expect(() => unsupported.value).toThrow('unsafe pointer dereference')
@@ -173,6 +227,110 @@ describe('builtin runtime contract helpers', () => {
     ])
   })
 
+  it('matches struct map keys by Go comparable value', () => {
+    class Key {
+      public _fields: {
+        name: ReturnType<typeof varRef<string>>
+        id: ReturnType<typeof varRef<number>>
+      }
+
+      constructor(name: string, id: number) {
+        this._fields = {
+          name: varRef(name),
+          id: varRef(id),
+        }
+      }
+    }
+
+    const m = makeMap<Key, string>()
+    mapSet(m, markAsStructValue(new Key('so-1', 7)), 'pending')
+    mapSet(m, markAsStructValue(new Key('so-1', 7)), 'accepted')
+
+    expect(m.size).toBe(1)
+    expect(mapGet(m, markAsStructValue(new Key('so-1', 7)), '')).toEqual([
+      'accepted',
+      true,
+    ])
+    expect(mapGet(m, markAsStructValue(new Key('so-2', 7)), '')).toEqual([
+      '',
+      false,
+    ])
+  })
+
+  it('does not compare runtime internals as generated struct values', () => {
+    class RuntimeType {
+      constructor(
+        private readonly name: string,
+        public readonly _fields: unknown[],
+      ) {}
+
+      String(): string {
+        return this.name
+      }
+    }
+
+    const m = makeMap<RuntimeType, string>()
+    mapSet(m, new RuntimeType('gob.wireType', []), 'wire')
+
+    expect(mapGet(m, new RuntimeType('gob.arrayType', []), '')).toEqual([
+      '',
+      false,
+    ])
+  })
+
+  it('tries duplicate runtime type registrations for colliding package names', () => {
+    class HashInterfaceImpl {
+      Write(_p: Bytes): [number, null] {
+        return [0, null]
+      }
+    }
+    class HashMessage {}
+
+    registerInterfaceType('collision.Hash', null, [
+      {
+        name: 'Write',
+        args: [
+          {
+            name: 'p',
+            type: {
+              kind: TypeKind.Slice,
+              elemType: { kind: TypeKind.Basic, name: 'uint8' },
+            },
+          },
+        ],
+        returns: [],
+      },
+    ])
+    registerStructType(
+      'collision.Hash',
+      new HashMessage(),
+      [],
+      HashMessage,
+      {},
+    )
+
+    expect(typeAssertTuple(new HashInterfaceImpl(), 'collision.Hash')[1]).toBe(
+      true,
+    )
+    expect(
+      typeAssertTuple(markAsStructValue(new HashMessage()), 'collision.Hash')[1],
+    ).toBe(true)
+  })
+
+  it('asserts interface-boxed named primitive values by declared type', () => {
+    const boxed = namedValueInterfaceValue(13, 'main.MyInt', {
+      Double: (receiver: number) => receiver * 2,
+    })
+
+    expect(
+      typeAssertTuple<number>(boxed, {
+        kind: TypeKind.Basic,
+        name: 'int',
+        typeName: 'main.MyInt',
+      }),
+    ).toEqual([13, true])
+  })
+
   it('exposes addressable slice and array index references', () => {
     const values = [1, 2, 3]
     const second = indexRef(values, 1)
@@ -199,8 +357,46 @@ describe('builtin runtime contract helpers', () => {
     fullBytes![7] = 12
     expect((byteBacking as Uint8Array)[7]).toBe(12)
 
+    const arrayPointer = arrayPointerFromIndexRef(indexRef(byteBacking, 1), 3)
+    const arrayView = pointerValue(arrayPointer) as Uint8Array
+    expect(len(arrayView)).toBe(3)
+    arrayView[2] = 19
+    expect((byteBacking as Uint8Array)[3]).toBe(19)
+
     shortBytes![0] = 14
     expect(bytesToUint8Array(shortBytes)).toEqual(new Uint8Array([14, 0]))
+
+    class Entry {
+      value = ''
+    }
+    const entries = makeSlice<Entry>(1, 3, undefined, () => new Entry())
+    const expanded = goSlice(entries, 0, 3)
+    const extra = indexRef(expanded, 2)
+    extra.value.value = 'zero-backed'
+    expect(pointerValue(extra).value).toBe('zero-backed')
+
+    const base = makeSlice<number>(1, 4, 'number')
+    base![0] = 7
+    const beforeAppend = goSlice(base, 0, 1)
+    const afterAppend = append(beforeAppend, 8, 9)
+    expect(len(beforeAppend)).toBe(1)
+    expect(len(afterAppend)).toBe(3)
+    expect([...afterAppend!]).toEqual([7, 8, 9])
+    expect(beforeAppend![0]).toBe(7)
+
+    const splitLeft = goSlice(afterAppend, 0, 1, 1)
+    expect(len(splitLeft)).toBe(1)
+    expect(cap(splitLeft)).toBe(1)
+    expect([...splitLeft!]).toEqual([7])
+
+    const text = varRef('abc')
+    const headerBytes = varRef(makeSlice<number>(0, 0, 'byte'))
+    const strh = pointerValue(stringHeaderRef(text))
+    const sh = pointerValue(sliceHeaderRef(headerBytes))
+    sh.Data = strh.Data
+    sh.Len = strh.Len
+    sh.Cap = strh.Len
+    expect(bytesToUint8Array(headerBytes.value)).toEqual(new Uint8Array([97, 98, 99]))
   })
 
   it('exposes stable synthetic slice index addresses', () => {
@@ -259,6 +455,21 @@ describe('builtin runtime contract helpers', () => {
     expect(typeAssert<Runner>(new Runner(), runnerInterface).ok).toBe(true)
     expect(typeAssert<Runner>(null, runnerInterface).ok).toBe(false)
 
+    const emptyInterface = registerInterfaceType('phase5.EmptyInterface', null, [])
+    const fn = functionValue(() => 'ok', {
+      kind: TypeKind.Function,
+      params: [],
+      results: [{ kind: TypeKind.Basic, name: 'string' }],
+    })
+    expect(typeAssert<typeof fn>(fn, emptyInterface)).toEqual({
+      ok: true,
+      value: fn,
+    })
+    expect(typeAssert<number>(3, emptyInterface)).toEqual({
+      ok: true,
+      value: 3,
+    })
+
     const nil = typedNil('*main.Example')
     expect(nil.__isTypedNil).toBe(true)
     expect(nil.__goType).toBe('*main.Example')
@@ -285,11 +496,9 @@ describe('builtin runtime contract helpers', () => {
       [{ name: 'Name', args: [], returns: [{ type: 'string' }] }],
       TypedDog,
     )
-    const dogInterface = registerInterfaceType(
-      'phase5.DogInterface',
-      null,
-      [{ name: 'Name', args: [], returns: [{ type: 'string' }] }],
-    )
+    const dogInterface = registerInterfaceType('phase5.DogInterface', null, [
+      { name: 'Name', args: [], returns: [{ type: 'string' }] },
+    ])
     const nilDog = interfaceValue<{ Name(): string } | null>(
       null,
       '*phase5.TypedDog',
@@ -304,11 +513,22 @@ describe('builtin runtime contract helpers', () => {
       }),
     ).toEqual({ value: null, ok: true })
 
-    const greet = namedFunction((name: string) => `hello ${name}`, 'phase5.Greet')
-    expect(typeAssert<typeof greet>(greet, {
-      kind: TypeKind.Function,
-      name: 'phase5.Greet',
-    }).ok).toBe(true)
+    const dogRef = interfaceValue<{ Name(): string } | null>(
+      { value: markAsStructValue(new TypedDog()), __isVarRef: true },
+      '*phase5.TypedDog',
+    )
+    expect(typeAssert<{ Name(): string }>(dogRef, dogInterface).ok).toBe(true)
+
+    const greet = namedFunction(
+      (name: string) => `hello ${name}`,
+      'phase5.Greet',
+    )
+    expect(
+      typeAssert<typeof greet>(greet, {
+        kind: TypeKind.Function,
+        name: 'phase5.Greet',
+      }).ok,
+    ).toBe(true)
     expect(
       typeAssert<{ Name: string }>(
         { Name: 'Alice' },
@@ -346,11 +566,71 @@ describe('builtin runtime contract helpers', () => {
 
   it('exposes channel helpers used by future lowering', async () => {
     const channel = makeChannel<number>(1, 0, 'both')
+    expect(cap(channel)).toBe(1)
     await channel.send(7)
     expect(len(channel)).toBe(1)
+    expect(cap(channel)).toBe(1)
     expect(await chanRecvWithOk(channel)).toEqual({ value: 7, ok: true })
     expect(len(channel)).toBe(0)
     channel.close()
     expect(await chanRecvWithOk(channel)).toEqual({ value: 0, ok: false })
   })
+
+  it('does not resume an unbuffered sender before the waiting receiver accepts the value', async () => {
+    const channel = makeChannel<number>(0, 0, 'both')
+    let received = 0
+
+    const receiver = (async () => {
+      received = await channel.receive()
+    })()
+
+    await channel.send(7)
+    expect(received).toBe(7)
+    await receiver
+  })
+
+  it('resumes closed-channel receivers after queued goroutine work', async () => {
+    const channel = makeChannel<number>(0, 0, 'both')
+    const events: string[] = []
+
+    const receive = channel.receive().then(() => {
+      events.push('receiver')
+    })
+    channel.close()
+    queueMicrotask(() => events.push('queued'))
+
+    await receive
+    expect(events).toEqual(['queued', 'receiver'])
+  })
+
+  it('cancels losing select receive cases', async () => {
+    const signal = makeChannel<string>(1, '', 'both')
+    const timeout = makeChannel<string>(0, '', 'both')
+    queueMicrotask(() => timeout.close())
+
+    await selectStatement(
+      [
+        {
+          id: 0,
+          isSend: false,
+          channel: signal,
+          onSelected: async () => 'signal',
+        },
+        {
+          id: 1,
+          isSend: false,
+          channel: timeout,
+          onSelected: async () => 'timeout',
+        },
+      ],
+      false,
+    )
+
+    await signal.send('value')
+    const received = await Promise.race([
+      signal.receive(),
+      new Promise<string>((resolve) => setTimeout(() => resolve('timeout'), 20)),
+    ])
+    expect(received).toBe('value')
+  })
 })

package/gs/builtin/slice.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+
+import { makeMap, mapGet, mapSet } from './map.js'
+import {
+  bytesToString,
+  copy,
+  indexString,
+  len,
+  sliceString,
+  stringCompare,
+  stringEqual,
+  stringToBytes,
+} from './slice.js'
+
+describe('builtin string byte representation', () => {
+  it('round-trips non-UTF-8 byte strings without external provenance', () => {
+    const original = new Uint8Array([0, 255, 128, 65, 66])
+    const str = bytesToString(original)
+
+    expect(Array.from(stringToBytes(str))).toEqual(Array.from(original))
+    expect(len(str)).toBe(original.length)
+    expect(indexString(str, 1)).toBe(255)
+    expect(Array.from(stringToBytes(sliceString(str, 1, 4)))).toEqual([
+      255, 128, 65,
+    ])
+  })
+
+  it('copies UTF-8 strings by bytes', () => {
+    const dst = new Uint8Array(3)
+
+    expect(copy(dst, '你')).toBe(3)
+    expect(Array.from(dst)).toEqual([0xe4, 0xbd, 0xa0])
+  })
+
+  it('compares byte-backed string aliases by bytes', () => {
+    const peerID = new Uint8Array([0, 255, 65])
+
+    expect(stringEqual(peerID, bytesToString(peerID))).toBe(true)
+    expect(stringEqual(peerID, '')).toBe(false)
+    expect(stringEqual(new Uint8Array(0), '')).toBe(true)
+  })
+
+  it('matches byte-backed strings as map keys', () => {
+    const raw = new Uint8Array([10, 36, 8, 1, 18, 32, 222, 187])
+    const key = bytesToString(raw)
+    const m = makeMap<string, string>()
+
+    mapSet(m, key, 'cached')
+
+    expect(mapGet(m, bytesToString(raw), '')).toEqual(['cached', true])
+  })
+
+  it('orders byte-backed strings by Go string bytes', () => {
+    expect(
+      stringCompare(new Uint8Array([0, 255]), new Uint8Array([1])),
+    ).toBeLessThan(0)
+    expect(
+      stringCompare(new Uint8Array([1]), new Uint8Array([0, 255])),
+    ).toBeGreaterThan(0)
+    expect(
+      stringCompare(new Uint8Array([1, 2]), new Uint8Array([1, 2, 0])),
+    ).toBeLessThan(0)
+    expect(
+      stringCompare(
+        bytesToString(new Uint8Array([255])),
+        new Uint8Array([255]),
+      ),
+    ).toBe(0)
+  })
+})