goscript 0.1.3 → 0.2.0

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

@@ -10,6 +10,7 @@ import {
   cloneStructValue,
   callGenericMethod,
   chanRecvWithOk,
+  fieldRef,
   functionValue,
   genericZero,
   goSlice,
@@ -28,6 +29,9 @@ import {
   namedFunction,
   namedValueInterfaceValue,
   newError,
+  ownedPointerAddress,
+  ownedPointerFromRef,
+  ownedPointerRef,
   pointerValue,
   print,
   println,
@@ -36,6 +40,7 @@ import {
   registerStructType,
   resetHostRuntimeForTests,
   selectStatement,
+  sliceFromOwnedPointer,
   sliceToArray,
   sliceHeaderRef,
   stringHeaderRef,
@@ -139,6 +144,12 @@ describe('builtin runtime contract helpers', () => {
     expect(uint(uint64And(0xf0n, 0x3cn), 32)).toBe(0x30)
     expect(uint(uint64Or(0xf0n, 0x0fn), 32)).toBe(0xff)
     expect(uint(uint64Xor(0xf0n, 0xffn), 32)).toBe(0x0f)
+    expect(
+      uint64And(
+        uint('18446744073709551615', 64),
+        uint('18014398509481983', 64),
+      ),
+    ).toBe(18014398509481983n)
     expect(uintShr(0x80000000, 31, 32)).toBe(1)
     expect(uintShr(0x80000000, 32, 32)).toBe(0)
     expect(uintShr(0xff, 4, 8)).toBe(15)
@@ -164,6 +175,9 @@ describe('builtin runtime contract helpers', () => {
       }),
     ).toEqual({ value: nilNamedSlice, ok: true })
     expect(pointerValue({ ok: true })).toEqual({ ok: true })
+    const nilSliceIface = interfaceValue(null, '[]*main.StatusEntry')
+    expect(len(nilSliceIface as any)).toBe(0)
+    expect(cap(nilSliceIface as any)).toBe(0)
     const namedPointerBox = namedValueInterfaceValue(
       varRef(new Uint8Array([1, 2])),
       '*main.Bytes',
@@ -181,9 +195,9 @@ describe('builtin runtime contract helpers', () => {
     expect(bytesToUint8Array(pointerValue(namedPointerMethodBox))).toEqual(
       new Uint8Array([1, 2, 3]),
     )
-    expect(bytesToUint8Array(goSlice(pointerValue(namedPointerMethodBox), 1))).toEqual(
-      new Uint8Array([2, 3]),
-    )
+    expect(
+      bytesToUint8Array(goSlice(pointerValue(namedPointerMethodBox), 1)),
+    ).toEqual(new Uint8Array([2, 3]))
     const namedStringBox = namedValueInterfaceValue('id', 'main.Name', {
       String: (receiver: string) => `name:${receiver}`,
     })
@@ -227,6 +241,31 @@ describe('builtin runtime contract helpers', () => {
     ])
   })
 
+  it('attaches owned pointer handles to variable and field refs', () => {
+    const local = varRef(1)
+    const localPointer = ownedPointerFromRef(local)
+    expect(localPointer).toBeDefined()
+    expect(ownedPointerRef(localPointer!)).toBe(local)
+    expect(ownedPointerAddress(localPointer!)).toBe(local.__goAddress!())
+    ownedPointerRef(localPointer!).value = 3
+    expect(local.value).toBe(3)
+    expect(() => sliceFromOwnedPointer(localPointer!, 1)).toThrow(
+      'reflect.SliceAt requires a GoScript-owned pointer',
+    )
+
+    const target = { count: 2 }
+    const count = fieldRef(target, 'count')
+    const countPointer = ownedPointerFromRef(count)
+    expect(countPointer).toBeDefined()
+    ownedPointerRef(countPointer!).value = 4
+    expect(target.count).toBe(4)
+
+    const sameField = fieldRef(target, 'count')
+    expect(ownedPointerAddress(ownedPointerFromRef(sameField)!)).toBe(
+      ownedPointerAddress(countPointer!),
+    )
+  })
+
   it('matches struct map keys by Go comparable value', () => {
     class Key {
       public _fields: {
@@ -301,19 +340,16 @@ describe('builtin runtime contract helpers', () => {
         returns: [],
       },
     ])
-    registerStructType(
-      'collision.Hash',
-      new HashMessage(),
-      [],
-      HashMessage,
-      {},
-    )
+    registerStructType('collision.Hash', new HashMessage(), [], HashMessage, [])
 
     expect(typeAssertTuple(new HashInterfaceImpl(), 'collision.Hash')[1]).toBe(
       true,
     )
     expect(
-      typeAssertTuple(markAsStructValue(new HashMessage()), 'collision.Hash')[1],
+      typeAssertTuple(
+        markAsStructValue(new HashMessage()),
+        'collision.Hash',
+      )[1],
     ).toBe(true)
   })
 
@@ -331,6 +367,30 @@ describe('builtin runtime contract helpers', () => {
     ).toEqual([13, true])
   })
 
+  it('asserts fixed-width numeric values by runtime type name', () => {
+    expect(
+      typeAssertTuple<number>(13, { kind: TypeKind.Basic, name: 'uint64' }),
+    ).toEqual([13, true])
+    expect(
+      typeAssertTuple<number>(13, { kind: TypeKind.Basic, name: 'int32' }),
+    ).toEqual([13, true])
+  })
+
+  it('asserts typed byte-slice pointers through uint8 descriptors', () => {
+    const bytes = varRef(makeSlice<number>(4, undefined, 'byte'))
+    const boxed = interfaceValue(bytes, '*[]byte')
+
+    expect(
+      typeAssertTuple<typeof bytes>(boxed, {
+        kind: TypeKind.Pointer,
+        elemType: {
+          kind: TypeKind.Slice,
+          elemType: { kind: TypeKind.Basic, name: 'uint8' },
+        },
+      }),
+    ).toEqual([bytes, true])
+  })
+
   it('exposes addressable slice and array index references', () => {
     const values = [1, 2, 3]
     const second = indexRef(values, 1)
@@ -396,7 +456,9 @@ describe('builtin runtime contract helpers', () => {
     sh.Data = strh.Data
     sh.Len = strh.Len
     sh.Cap = strh.Len
-    expect(bytesToUint8Array(headerBytes.value)).toEqual(new Uint8Array([97, 98, 99]))
+    expect(bytesToUint8Array(headerBytes.value)).toEqual(
+      new Uint8Array([97, 98, 99]),
+    )
   })
 
   it('exposes stable synthetic slice index addresses', () => {
@@ -411,6 +473,27 @@ describe('builtin runtime contract helpers', () => {
     expect(indexAddress(other, 0)).not.toBe(indexAddress(left, 0))
   })
 
+  it('exposes owned pointer handles for addressable collection elements', () => {
+    const values = [1, 2, 3, 4]
+    const second = indexRef(values, 1)
+    const pointer = ownedPointerFromRef(second)
+
+    expect(pointer).toBeDefined()
+    expect(ownedPointerAddress(pointer!)).toBe(indexAddress(values, 1))
+    ownedPointerRef(pointer!).value = 8
+    expect(values).toEqual([1, 8, 3, 4])
+
+    const view = sliceFromOwnedPointer(pointer!, 2) as number[]
+    view[1] = 12
+    expect(values).toEqual([1, 8, 12, 4])
+
+    const bytes = new Uint8Array([5, 6, 7])
+    const bytePointer = ownedPointerFromRef(indexRef<number>(bytes, 1))
+    const byteView = sliceFromOwnedPointer(bytePointer!, 2) as Uint8Array
+    byteView[0] = 9
+    expect(Array.from(bytes)).toEqual([5, 9, 7])
+  })
+
   it('copies slices into fixed arrays with Go length checks', () => {
     const source = goSlice([1, 2, 3], 1, 3)
     const array = sliceToArray<number>(source, 2)
@@ -455,7 +538,11 @@ 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 emptyInterface = registerInterfaceType(
+      'phase5.EmptyInterface',
+      null,
+      [],
+    )
     const fn = functionValue(() => 'ok', {
       kind: TypeKind.Function,
       params: [],
@@ -519,28 +606,55 @@ describe('builtin runtime contract helpers', () => {
     )
     expect(typeAssert<{ Name(): string }>(dogRef, dogInterface).ok).toBe(true)
 
+    const bytesRef = varRef<Bytes>(new Uint8Array([1, 2, 3]))
+    const boxedBytesRef = interfaceValue<any>(bytesRef, '*[]byte')
+    const [assertedBytesRef, bytesOk] = typeAssertTuple<typeof bytesRef>(
+      boxedBytesRef,
+      {
+        kind: TypeKind.Pointer,
+        elemType: {
+          kind: TypeKind.Slice,
+          elemType: { kind: TypeKind.Basic, name: 'int' },
+        },
+      },
+    )
+    expect(bytesOk).toBe(true)
+    expect(pointerValue(assertedBytesRef)).toBe(bytesRef.value)
+
+    const greetInfo = {
+      kind: TypeKind.Function,
+      name: 'phase5.Greet',
+      params: [{ kind: TypeKind.Basic, name: 'string' }],
+      results: [{ kind: TypeKind.Basic, name: 'string' }],
+    }
     const greet = namedFunction(
       (name: string) => `hello ${name}`,
       'phase5.Greet',
+      greetInfo,
     )
+    expect(typeAssert<typeof greet>(greet, greetInfo).ok).toBe(true)
     expect(
       typeAssert<typeof greet>(greet, {
         kind: TypeKind.Function,
         name: 'phase5.Greet',
+        params: [{ kind: TypeKind.Basic, name: 'int' }],
+        results: [{ kind: TypeKind.Basic, name: 'string' }],
       }).ok,
-    ).toBe(true)
+    ).toBe(false)
     expect(
       typeAssert<{ Name: string }>(
         { Name: 'Alice' },
         {
           kind: TypeKind.Struct,
           methods: [],
-          fields: {
-            Name: {
+          fields: [
+            {
+              name: 'Name',
+              key: 'Name',
               type: { kind: TypeKind.Basic, name: 'string' },
               tag: 'json:"name"',
             },
-          },
+          ],
         },
       ).ok,
     ).toBe(true)
@@ -551,6 +665,20 @@ describe('builtin runtime contract helpers', () => {
     })
     expect(literal(7)).toBe('7')
     expect(literal).toHaveProperty('__typeInfo')
+    expect(
+      typeAssert<typeof literal>(literal, {
+        kind: TypeKind.Function,
+        params: [{ kind: TypeKind.Basic, name: 'int' }],
+        results: [{ kind: TypeKind.Basic, name: 'string' }],
+      }).ok,
+    ).toBe(true)
+    expect(
+      typeAssert<(...args: unknown[]) => unknown>(() => undefined, {
+        kind: TypeKind.Function,
+        params: [],
+        results: [],
+      }).ok,
+    ).toBe(false)
 
     const genericArgs = {
       T: {
@@ -564,6 +692,118 @@ describe('builtin runtime contract helpers', () => {
     expect(callGenericMethod(genericArgs, 'T', 'String', 12)).toBe('12')
   })
 
+  it('compares anonymous descriptors inside function assertions', () => {
+    const acceptsAny = functionValue((value: unknown) => String(value), {
+      kind: TypeKind.Function,
+      name: 'main.AcceptsAny',
+      params: [{ kind: TypeKind.Interface, methods: [] }],
+      results: [{ kind: TypeKind.Basic, name: 'string' }],
+    })
+
+    expect(
+      typeAssert<typeof acceptsAny>(acceptsAny, {
+        kind: TypeKind.Function,
+        name: 'main.AcceptsAny',
+        params: [{ kind: TypeKind.Interface, methods: [] }],
+        results: [{ kind: TypeKind.Basic, name: 'string' }],
+      }).ok,
+    ).toBe(true)
+
+    const acceptsStruct = functionValue(
+      (value: { Name: string }) => value.Name,
+      {
+        kind: TypeKind.Function,
+        name: 'main.AcceptsStruct',
+        params: [
+          {
+            kind: TypeKind.Struct,
+            methods: [],
+            fields: [
+              {
+                name: 'Name',
+                type: { kind: TypeKind.Basic, name: 'string' },
+                tag: 'json:"name"',
+              },
+            ],
+          },
+        ],
+        results: [{ kind: TypeKind.Basic, name: 'string' }],
+      },
+    )
+
+    expect(
+      typeAssert<typeof acceptsStruct>(acceptsStruct, {
+        kind: TypeKind.Function,
+        name: 'main.AcceptsStruct',
+        params: [
+          {
+            kind: TypeKind.Struct,
+            methods: [],
+            fields: [
+              {
+                name: 'Name',
+                type: { kind: TypeKind.Basic, name: 'string' },
+                tag: 'json:"name"',
+              },
+            ],
+          },
+        ],
+        results: [{ kind: TypeKind.Basic, name: 'string' }],
+      }).ok,
+    ).toBe(true)
+    expect(
+      typeAssert<typeof acceptsStruct>(acceptsStruct, {
+        kind: TypeKind.Function,
+        name: 'main.AcceptsStruct',
+        params: [
+          {
+            kind: TypeKind.Struct,
+            methods: [],
+            fields: [
+              {
+                name: 'Name',
+                type: { kind: TypeKind.Basic, name: 'string' },
+                tag: 'json:"other"',
+              },
+            ],
+          },
+        ],
+        results: [{ kind: TypeKind.Basic, name: 'string' }],
+      }).ok,
+    ).toBe(false)
+
+    const acceptsAlias = functionValue((value: number) => value, {
+      kind: TypeKind.Function,
+      name: 'main.AcceptsAlias',
+      params: [{ kind: TypeKind.Basic, name: 'int', typeName: 'main.A' }],
+      results: [{ kind: TypeKind.Basic, name: 'int' }],
+    })
+    expect(
+      typeAssert<typeof acceptsAlias>(acceptsAlias, {
+        kind: TypeKind.Function,
+        name: 'main.AcceptsAlias',
+        params: [{ kind: TypeKind.Basic, name: 'int', typeName: 'main.A' }],
+        results: [{ kind: TypeKind.Basic, name: 'int' }],
+      }).ok,
+    ).toBe(true)
+    expect(
+      typeAssert<typeof acceptsAlias>(acceptsAlias, {
+        kind: TypeKind.Function,
+        name: 'main.AcceptsAlias',
+        params: [{ kind: TypeKind.Basic, name: 'int', typeName: 'main.B' }],
+        results: [{ kind: TypeKind.Basic, name: 'int' }],
+      }).ok,
+    ).toBe(false)
+    expect(
+      typeAssert<typeof acceptsAlias>(acceptsAlias, {
+        kind: TypeKind.Function,
+        name: 'main.AcceptsAlias',
+        params: [{ kind: TypeKind.Basic, name: 'int' }],
+        results: [{ kind: TypeKind.Basic, name: 'int' }],
+      }).ok,
+    ).toBe(false)
+  })
+
   it('exposes channel helpers used by future lowering', async () => {
     const channel = makeChannel<number>(1, 0, 'both')
     expect(cap(channel)).toBe(1)
@@ -629,7 +869,9 @@ describe('builtin runtime contract helpers', () => {
     await signal.send('value')
     const received = await Promise.race([
       signal.receive(),
-      new Promise<string>((resolve) => setTimeout(() => resolve('timeout'), 20)),
+      new Promise<string>((resolve) =>
+        setTimeout(() => resolve('timeout'), 20),
+      ),
     ])
     expect(received).toBe('value')
   })

package/gs/builtin/slice.ts

@@ -1,4 +1,10 @@
-import { isVarRef, varRef, type VarRef } from './varRef.js'
+import {
+  isOwnedPointerHandle,
+  isVarRef,
+  varRef,
+  type OwnedPointerHandle,
+  type VarRef,
+} from './varRef.js'
 
 export class GoBinaryString extends String {
   readonly bytes: Uint8Array
@@ -1291,7 +1297,7 @@ export function indexRef<T>(
         `runtime error: index out of range [${index}] with length ${collection.length}`,
       )
     }
-    return {
+    const ref: VarRef<T> = {
       get value() {
         return collection[index] as T
       },
@@ -1303,6 +1309,8 @@ export function indexRef<T>(
       __goCollection: collection,
       __goIndex: index,
     }
+    ref.__goPointer = collectionPointer(ref, collection, index)
+    return ref
   }
   if (isComplexSlice(collection)) {
     if (index < 0 || index >= collection.__meta__.length) {
@@ -1311,7 +1319,7 @@ export function indexRef<T>(
       )
     }
     const backingIndex = collection.__meta__.offset + index
-    return {
+    const ref: VarRef<T> = {
       get value() {
         return collection.__meta__.backing[backingIndex]
       },
@@ -1323,6 +1331,8 @@ export function indexRef<T>(
       __goCollection: collection,
       __goIndex: index,
     }
+    ref.__goPointer = collectionPointer(ref, collection, index)
+    return ref
   }
   if (Array.isArray(collection)) {
     if (index < 0 || index >= collection.length) {
@@ -1330,7 +1340,7 @@ export function indexRef<T>(
         `runtime error: index out of range [${index}] with length ${collection.length}`,
       )
     }
-    return {
+    const ref: VarRef<T> = {
       get value() {
         return collection[index]
       },
@@ -1342,10 +1352,40 @@ export function indexRef<T>(
       __goCollection: collection,
       __goIndex: index,
     }
+    ref.__goPointer = collectionPointer(ref, collection, index)
+    return ref
   }
   throw new Error('runtime error: index on unsupported type')
 }
 
+function collectionPointer<T>(
+  ref: VarRef<T>,
+  collection: Slice<T> | T[] | Uint8Array,
+  index: number,
+): OwnedPointerHandle<T> {
+  return {
+    __goOwnedPointer: true,
+    __goAddress: () => indexAddress(collection, index),
+    __goRef: () => ref,
+    __goSlice: (length: number) => {
+      if (length < 0) {
+        throw new Error('runtime error: unsafe slice length out of range')
+      }
+      return goSlice(collection as any, index, index + length, index + length)
+    },
+  }
+}
+
+export function sliceFromOwnedPointer<T>(
+  pointer: OwnedPointerHandle<T>,
+  length: number,
+): Slice<T> | Uint8Array {
+  if (!isOwnedPointerHandle(pointer) || pointer.__goSlice === undefined) {
+    throw new Error('reflect.SliceAt requires a GoScript-owned pointer')
+  }
+  return pointer.__goSlice(length) as Slice<T> | Uint8Array
+}
+
 /**
  * arrayPointerFromIndexRef turns &slice[i] into a pointer to an N-element array
  * view. This models unsafe conversions such as (*[64]byte)(unsafe.Pointer(&b[0]))
@@ -1684,6 +1724,13 @@ function collectionValue(value: unknown): unknown {
   if (isVarRef(value)) {
     return collectionValue(value.value)
   }
+  if (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { __isTypedNil?: unknown }).__isTypedNil === true
+  ) {
+    return null
+  }
   if (
     typeof value === 'object' &&
     value !== null &&