goscript 0.1.4 → 0.2.1

package/gs/builtin/hostio.ts

@@ -104,6 +104,7 @@ export type MainScriptMeta = {
 }
 
 const encoder = new TextEncoder()
+const decoder = new TextDecoder()
 
 function getDynamicRequire(): ((specifier: string) => unknown) | null {
   try {
@@ -342,6 +343,12 @@ function detectHostRuntime(): HostRuntime {
         buffer,
       )
     }
+    if (fd === 1 || fd === 2) {
+      fallbackConsoleWriter(fd === 2 ? 'error' : 'log')(
+        decoder.decode(buffer),
+      )
+      return buffer.length
+    }
     throw new HostUnsupportedError()
   }
   const writeStdoutText: HostTextWrite = (data: string) => {

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

@@ -10,12 +10,14 @@ import {
   cloneStructValue,
   callGenericMethod,
   chanRecvWithOk,
+  fieldRef,
   functionValue,
   genericZero,
   goSlice,
   int,
   arrayPointerFromIndexRef,
   indexAddress,
+  indexByteAddress,
   indexRef,
   interfaceValue,
   len,
@@ -28,6 +30,9 @@ import {
   namedFunction,
   namedValueInterfaceValue,
   newError,
+  ownedPointerAddress,
+  ownedPointerFromRef,
+  ownedPointerRef,
   pointerValue,
   print,
   println,
@@ -36,6 +41,7 @@ import {
   registerStructType,
   resetHostRuntimeForTests,
   selectStatement,
+  sliceFromOwnedPointer,
   sliceToArray,
   sliceHeaderRef,
   stringHeaderRef,
@@ -57,6 +63,7 @@ import {
   uintShr,
   unref,
   unsupportedPointerRef,
+  unsafePointerRef,
   varRef,
 } from './index.js'
 
@@ -139,9 +146,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(
+      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)
@@ -187,9 +197,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}`,
     })
@@ -233,6 +243,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: {
@@ -307,19 +342,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)
   })
 
@@ -393,6 +425,16 @@ describe('builtin runtime contract helpers', () => {
     arrayView[2] = 19
     expect((byteBacking as Uint8Array)[3]).toBe(19)
 
+    const words = [0x11223344, 0]
+    const wordBytes = arrayPointerFromIndexRef(indexRef(words, 0), 8, 4, 1)
+    const byteView = pointerValue(wordBytes) as number[]
+    expect(byteView[0]).toBe(0x44)
+    expect(byteView[3]).toBe(0x11)
+    byteView[4] = 0xaa
+    expect(words[1]).toBe(0xaa)
+    wordBytes.value = [1, 2, 3, 4]
+    expect(words[0]).toBe(0x04030201)
+
     shortBytes![0] = 14
     expect(bytesToUint8Array(shortBytes)).toEqual(new Uint8Array([14, 0]))
 
@@ -426,7 +468,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', () => {
@@ -441,6 +485,43 @@ describe('builtin runtime contract helpers', () => {
     expect(indexAddress(other, 0)).not.toBe(indexAddress(left, 0))
   })
 
+  it('resolves unsafe byte addresses within numeric slice elements', () => {
+    const words = makeSlice<number>(2, undefined, 'number')
+    const first = indexByteAddress(words, 0, 8)
+    const second = indexByteAddress(words, 1, 8)
+
+    expect(second - first).toBe(8)
+    unsafePointerRef<number>(first + 1).value = 0x12
+    unsafePointerRef<number>(first + 7).value = 0x80
+    expect(unsafePointerRef<number>(first + 1).value).toBe(0x12)
+    expect(unsafePointerRef<number>(first + 7).value).toBe(0x80)
+    expect(words![0]).toBe(0x8000000000001200n as unknown as number)
+
+    unsafePointerRef<number>(second).value = 0x34
+    expect(words![1]).toBe(0x34)
+  })
+
+  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)
@@ -485,7 +566,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: [],
@@ -564,28 +649,40 @@ describe('builtin runtime contract helpers', () => {
     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)
@@ -596,6 +693,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: {
@@ -609,6 +720,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)
@@ -674,7 +897,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')
   })