goscript 0.1.4 → 0.2.1

package/gs/reflect/typefor.test.ts

@@ -1,8 +1,11 @@
 import { describe, it, expect } from 'vitest'
 import {
+  interfaceValue,
+  makeChannel,
   makeMap,
   mapGet,
   mapSet,
+  markAsStructValue,
   namedValueInterfaceValue,
   TypeKind,
   registerInterfaceType,
@@ -10,7 +13,19 @@ import {
   varRef,
 } from '../builtin/index.js'
 import { StructField } from './types.js'
-import { Int, Ptr, Struct, TypeFor, TypeOf, Uint64, ValueOf } from './type.js'
+import { SelectCase, SelectRecv } from './types.js'
+import {
+  Chan,
+  Int,
+  Ptr,
+  Struct,
+  StructOf,
+  TypeFor,
+  TypeOf,
+  Uint64,
+  ValueOf,
+} from './type.js'
+import { Indirect, New, Select, Zero } from './value.js'
 
 describe('TypeFor', () => {
   it('exposes StructField PkgPath and exported semantics', () => {
@@ -50,6 +65,101 @@ describe('TypeFor', () => {
     expect(namedIntType.Kind()).toBe(Int)
   })
 
+  it('preserves generic method signatures for named basic types', () => {
+    const stringResult = { kind: TypeKind.Basic, name: 'string' } as const
+    const namedIntDescriptor = {
+      kind: TypeKind.Basic,
+      name: 'int',
+      typeName: 'main.MyInt',
+    } as const
+    const methodSignatures = [
+      {
+        name: 'String',
+        args: [],
+        returns: [{ type: stringResult }],
+      },
+    ]
+    const preexisting = TypeFor({
+      T: {
+        type: namedIntDescriptor,
+        zero: () => 0,
+      },
+    })
+
+    const namedIntType = TypeFor({
+      T: {
+        type: namedIntDescriptor,
+        zero: () => 0,
+        methods: { String: (receiver: number) => String(receiver) },
+        methodSignatures,
+      },
+    })
+    const stringerType = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Interface,
+          methods: methodSignatures,
+        },
+        zero: () => null,
+      },
+    })
+
+    expect(namedIntType).toBe(preexisting)
+    expect(namedIntType.NumMethod()).toBe(1)
+    const [method, ok] = namedIntType.MethodByName('String')
+    expect(ok).toBe(true)
+    expect(method.Type.NumIn()).toBe(1)
+    expect(method.Type.NumOut()).toBe(1)
+    expect(method.Type.Out(0).String()).toBe('string')
+    expect(namedIntType.Implements(stringerType)).toBe(true)
+  })
+
+  it('preserves generic method signatures for pointers to named basic types', () => {
+    const stringResult = { kind: TypeKind.Basic, name: 'string' } as const
+    const methodSignatures = [
+      {
+        name: 'String',
+        args: [],
+        returns: [{ type: stringResult }],
+      },
+    ]
+    const pointerType = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Pointer,
+          elemType: {
+            kind: TypeKind.Basic,
+            name: 'bool',
+            typeName: 'main.MyBool',
+          },
+        },
+        zero: () => null,
+        methods: { String: () => 'true' },
+        methodSignatures,
+      },
+    })
+    const stringerType = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Interface,
+          methods: methodSignatures,
+        },
+        zero: () => null,
+      },
+    })
+
+    expect(pointerType.Kind()).toBe(Ptr)
+    expect(pointerType.String()).toBe('*main.MyBool')
+    expect(pointerType.NumMethod()).toBe(1)
+    const [method, ok] = pointerType.MethodByName('String')
+    expect(ok).toBe(true)
+    expect(method.Type.NumIn()).toBe(1)
+    expect(method.Type.In(0)).toBe(pointerType)
+    expect(method.Type.NumOut()).toBe(1)
+    expect(method.Type.Out(0).String()).toBe('string')
+    expect(pointerType.Implements(stringerType)).toBe(true)
+  })
+
   it('preserves named pointer type metadata on interface boxes', () => {
     const target = varRef(0)
     const boxed = namedValueInterfaceValue(
@@ -78,6 +188,22 @@ describe('TypeFor', () => {
     expect(target.value).toBe(15)
   })
 
+  it('preserves channel type metadata on interface boxes', () => {
+    const ch = makeChannel<{}>(0, {}, 'both')
+    const chanValue = ValueOf(interfaceValue(ch, '<-chan struct{}'))
+
+    expect(chanValue.Type().Kind()).toBe(Chan)
+    expect(chanValue.Type().String()).toBe('<-chan struct {}')
+    expect(chanValue.Type().Elem().Kind()).toBe(Struct)
+
+    const [chosen, recv, ok] = Select([
+      new SelectCase({ Dir: SelectRecv, Chan: chanValue }),
+    ])
+    expect(chosen).toBe(0)
+    expect(ok).toBe(true)
+    expect(recv.Type().String()).toBe('struct {}')
+  })
+
   it('formats literal interface methods from type metadata', () => {
     const ifaceType = TypeFor({
       T: {
@@ -92,6 +218,130 @@ describe('TypeFor', () => {
     expect(ifaceType.String()).toBe('interface { SomeMethod() }')
   })
 
+  it('handles recursive interface method metadata', () => {
+    const recursiveMethod = {
+      name: 'Visit',
+      args: [{ name: 'next', type: 'main.RecursiveInterface' }],
+      returns: [{ name: '_r0', type: 'main.RecursiveInterface' }],
+    }
+    registerInterfaceType('main.RecursiveInterface', null, [recursiveMethod])
+
+    class RecursiveImpl {
+      public Visit(next: unknown): unknown {
+        return next
+      }
+    }
+
+    const typeInfo = registerStructType(
+      'main.RecursiveImpl',
+      new RecursiveImpl(),
+      [recursiveMethod],
+      RecursiveImpl,
+      [],
+    )
+    ;(RecursiveImpl as any).__typeInfo = typeInfo
+
+    const ifaceType = TypeFor({
+      T: { type: 'main.RecursiveInterface', zero: () => null },
+    })
+
+    expect(ifaceType.String()).toBe(
+      'interface { Visit(main.RecursiveInterface) main.RecursiveInterface }',
+    )
+    expect(ifaceType.AssignableTo(ifaceType)).toBe(true)
+    expect(TypeOf(new RecursiveImpl()).AssignableTo(ifaceType)).toBe(true)
+  })
+
+  it('handles recursive struct field metadata', () => {
+    class RecursiveNode {
+      public Next: RecursiveNode | null = null
+    }
+
+    const typeInfo = registerStructType(
+      'main.RecursiveNode',
+      new RecursiveNode(),
+      [],
+      RecursiveNode,
+      [
+        {
+          name: 'Next',
+          key: 'Next',
+          type: {
+            kind: TypeKind.Pointer,
+            elemType: 'main.RecursiveNode',
+          },
+        },
+      ],
+    )
+    Object.assign(RecursiveNode, { __typeInfo: typeInfo })
+
+    const nodeType = TypeFor({
+      T: { type: 'main.RecursiveNode', zero: () => new RecursiveNode() },
+    })
+
+    expect(nodeType.Kind()).toBe(Struct)
+    expect(nodeType.Field(0).Name).toBe('Next')
+    expect(nodeType.Field(0).Type.String()).toBe('*main.RecursiveNode')
+    expect(nodeType.Field(0).Type.Elem().NumField()).toBe(1)
+    expect(nodeType.Field(0).Type.Elem().Field(0).Type.String()).toBe(
+      '*main.RecursiveNode',
+    )
+    expect(TypeOf(new RecursiveNode()).Field(0).Type.String()).toBe(
+      '*main.RecursiveNode',
+    )
+    expect(TypeOf(new RecursiveNode()).Field(0).Type.Elem().NumField()).toBe(1)
+  })
+
+  it('keeps mutually recursive registered struct identity canonical', () => {
+    class RecursiveA {
+      public B: RecursiveB | null = null
+    }
+    class RecursiveB {
+      public A: RecursiveA | null = null
+    }
+
+    const aInfo = registerStructType(
+      'main.RecursiveA',
+      new RecursiveA(),
+      [],
+      RecursiveA,
+      [
+        {
+          name: 'B',
+          key: 'B',
+          type: { kind: TypeKind.Pointer, elemType: 'main.RecursiveB' },
+        },
+      ],
+    )
+    const bInfo = registerStructType(
+      'main.RecursiveB',
+      new RecursiveB(),
+      [],
+      RecursiveB,
+      [
+        {
+          name: 'A',
+          key: 'A',
+          type: { kind: TypeKind.Pointer, elemType: 'main.RecursiveA' },
+        },
+      ],
+    )
+    Object.assign(RecursiveA, { __typeInfo: aInfo })
+    Object.assign(RecursiveB, { __typeInfo: bInfo })
+
+    const aType = TypeFor({
+      T: { type: 'main.RecursiveA', zero: () => new RecursiveA() },
+    })
+    const bType = TypeFor({
+      T: { type: 'main.RecursiveB', zero: () => new RecursiveB() },
+    })
+    const bFromA = aType.Field(0).Type.Elem()
+
+    expect(bFromA.NumField()).toBe(1)
+    expect(bFromA).toBe(bType)
+    expect(bType.Field(0).Type.Elem()).toBe(aType)
+  })
+
   it('formats unnamed function signatures from type metadata', () => {
     const fnType = TypeFor({
       T: {
@@ -105,6 +355,194 @@ describe('TypeFor', () => {
     })
 
     expect(fnType.String()).toBe('func(int) string')
+    expect(fnType.NumIn()).toBe(1)
+    expect(fnType.In(0).String()).toBe('int')
+    expect(fnType.NumOut()).toBe(1)
+    expect(fnType.Out(0).String()).toBe('string')
+    expect(fnType.IsVariadic()).toBe(false)
+  })
+
+  it('preserves named and variadic function descriptors', () => {
+    const namedFnType = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Function,
+          name: 'example.test.Callback',
+          params: [{ kind: TypeKind.Basic, name: 'int' }],
+          results: [{ kind: TypeKind.Basic, name: 'string' }],
+        },
+        zero: () => null,
+      },
+    })
+
+    expect(namedFnType.String()).toBe('example.test.Callback')
+    expect(namedFnType.PkgPath()).toBe('example.test')
+    expect(namedFnType.Name()).toBe('Callback')
+    expect(namedFnType.NumIn()).toBe(1)
+    expect(namedFnType.In(0).String()).toBe('int')
+    expect(namedFnType.NumOut()).toBe(1)
+    expect(namedFnType.Out(0).String()).toBe('string')
+
+    const variadicFnType = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Function,
+          params: [
+            {
+              kind: TypeKind.Slice,
+              elemType: { kind: TypeKind.Basic, name: 'string' },
+            },
+          ],
+          results: [{ kind: TypeKind.Basic, name: 'int' }],
+          isVariadic: true,
+        },
+        zero: () => null,
+      },
+    })
+
+    expect(variadicFnType.String()).toBe('func(...string) int')
+    expect(variadicFnType.NumIn()).toBe(1)
+    expect(variadicFnType.In(0).String()).toBe('[]string')
+    expect(variadicFnType.NumOut()).toBe(1)
+    expect(variadicFnType.Out(0).String()).toBe('int')
+    expect(variadicFnType.IsVariadic()).toBe(true)
+  })
+
+  it('rehydrates anonymous struct descriptors as unnamed struct types', () => {
+    const intType = TypeOf(0)
+    const descriptor = {
+      kind: TypeKind.Struct,
+      methods: [],
+      fields: [
+        {
+          name: 'X',
+          key: 'X',
+          type: { kind: TypeKind.Basic, name: 'int' },
+          tag: 'json:"x"',
+          index: [0],
+          offset: 0,
+          exported: true,
+        },
+      ],
+    } as const
+
+    const typ = TypeFor({
+      T: {
+        type: descriptor,
+        zero: () => ({ X: 0 }),
+      },
+    })
+    const dynamic = StructOf([
+      new StructField({
+        Name: 'X',
+        Type: intType,
+        Tag: 'json:"x"',
+      }),
+    ])
+
+    expect(typ.String()).toBe('struct { X int "json:\\"x\\"" }')
+    expect(typ.Name()).toBe('')
+    expect(typ.PkgPath()).toBe('')
+    expect(typ.NumField()).toBe(1)
+    expect(typ.Field(0).Name).toBe('X')
+    expect(typ.Field(0).Tag.Get('json')).toBe('x')
+    expect(typ.AssignableTo(dynamic)).toBe(true)
+    expect(dynamic.AssignableTo(typ)).toBe(true)
+  })
+
+  it('uses full anonymous struct identity in method signatures', () => {
+    const baseField = {
+      name: 'X',
+      key: 'X',
+      type: { kind: TypeKind.Basic, name: 'int' },
+      index: [0],
+      offset: 0,
+      exported: true,
+    } as const
+    const taggedParam = {
+      kind: TypeKind.Struct,
+      methods: [],
+      fields: [{ ...baseField, tag: 'json:"a"' }],
+    } as const
+    const methodSignatures = [
+      {
+        name: 'Accept',
+        args: [{ type: taggedParam }],
+        returns: [],
+      },
+    ]
+    const receiverType = TypeFor({
+      T: {
+        type: { kind: TypeKind.Basic, name: 'int', typeName: 'main.Receiver' },
+        zero: () => 0,
+        methodSignatures,
+      },
+    })
+    const sameInterface = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Interface,
+          methods: methodSignatures,
+        },
+        zero: () => null,
+      },
+    })
+    const differentTagInterface = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Interface,
+          methods: [
+            {
+              name: 'Accept',
+              args: [
+                {
+                  type: {
+                    kind: TypeKind.Struct,
+                    methods: [],
+                    fields: [{ ...baseField, tag: 'json:"b"' }],
+                  },
+                },
+              ],
+              returns: [],
+            },
+          ],
+        },
+        zero: () => null,
+      },
+    })
+    const differentEmbeddingInterface = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Interface,
+          methods: [
+            {
+              name: 'Accept',
+              args: [
+                {
+                  type: {
+                    kind: TypeKind.Struct,
+                    methods: [],
+                    fields: [
+                      {
+                        ...baseField,
+                        tag: 'json:"a"',
+                        anonymous: true,
+                      },
+                    ],
+                  },
+                },
+              ],
+              returns: [],
+            },
+          ],
+        },
+        zero: () => null,
+      },
+    })
+
+    expect(receiverType.Implements(sameInterface)).toBe(true)
+    expect(receiverType.Implements(differentTagInterface)).toBe(false)
+    expect(receiverType.Implements(differentEmbeddingInterface)).toBe(false)
   })
 
   it('resolves registered type names from descriptors', () => {
@@ -115,25 +553,39 @@ describe('TypeFor', () => {
       new RegisteredStruct(),
       [],
       RegisteredStruct,
-      {},
+      [],
     )
     registerStructType(
       'main.RegisteredWithFields',
       new RegisteredWithFields(),
       [],
       RegisteredWithFields,
-      {
-        Name: { kind: TypeKind.Basic, name: 'string' },
-        Count: {
+      [
+        {
+          name: 'Name',
+          key: 'Name',
+          type: { kind: TypeKind.Basic, name: 'string' },
+        },
+        {
+          key: 'Count',
           name: 'Total',
           type: { kind: TypeKind.Basic, name: 'int' },
           tag: 'json:"total"',
+          pkgPath: 'main',
+          anonymous: true,
+          index: [3],
+          offset: 24,
+          exported: false,
         },
-        Items: {
-          kind: TypeKind.Slice,
-          elemType: 'main.RegisteredStruct',
+        {
+          name: 'Items',
+          key: 'Items',
+          type: {
+            kind: TypeKind.Slice,
+            elemType: 'main.RegisteredStruct',
+          },
         },
-      },
+      ],
     )
     registerInterfaceType('main.RegisteredInterface', null, [
       { name: 'SomeMethod', args: [], returns: [] },
@@ -160,9 +612,77 @@ describe('TypeFor', () => {
     expect(fieldsType.Field(0).Name).toBe('Name')
     expect(fieldsType.Field(0).Type.String()).toBe('string')
     expect(fieldsType.Field(1).Name).toBe('Total')
+    expect(fieldsType.Field(1).PkgPath).toBe('main')
+    expect(fieldsType.Field(1).IsExported()).toBe(false)
+    expect(fieldsType.Field(1).Anonymous).toBe(true)
+    expect(fieldsType.Field(1).Index).toEqual([3])
+    expect(fieldsType.Field(1).Offset).toBe(24)
     expect(fieldsType.Field(1).Tag.Get('json')).toBe('total')
     expect(fieldsType.Field(2).Type.String()).toBe('[]main.RegisteredStruct')
-    expect(fieldsType.Field(2).Type.Elem().String()).toBe('main.RegisteredStruct')
+    expect(fieldsType.Field(2).Type.Elem().String()).toBe(
+      'main.RegisteredStruct',
+    )
+  })
+
+  it('allocates registered struct zero values through the named constructor', () => {
+    class RegisteredZero {
+      public get Name(): string {
+        return this._fields.Name.value
+      }
+      public set Name(value: string) {
+        this._fields.Name.value = value
+      }
+
+      public _fields: {
+        Name: ReturnType<typeof varRef<string>>
+      }
+
+      constructor(init?: Partial<{ Name?: string }>) {
+        this._fields = {
+          Name: varRef(init?.Name ?? ''),
+        }
+      }
+
+      public clone(): RegisteredZero {
+        return markAsStructValue(new RegisteredZero({ Name: this.Name }))
+      }
+    }
+
+    const typeInfo = registerStructType(
+      'main.RegisteredZero',
+      () => new RegisteredZero(),
+      [],
+      RegisteredZero,
+      [
+        {
+          name: 'Name',
+          key: 'Name',
+          type: { kind: TypeKind.Basic, name: 'string' },
+          index: [0],
+          offset: 0,
+          exported: true,
+        },
+      ],
+    )
+    ;(RegisteredZero as any).__typeInfo = typeInfo
+
+    const typ = TypeOf(new RegisteredZero())
+    expect(Zero(typ).Interface()).toBeInstanceOf(RegisteredZero)
+    expect(TypeOf(Zero(typ).Interface()).String()).toBe('main.RegisteredZero')
+
+    const ptr = New(typ)
+    expect(ptr.Elem().Interface()).toBeInstanceOf(RegisteredZero)
+    ptr.Elem().FieldByName('Name').SetString('Ada')
+    expect((ptr.Elem().Interface() as RegisteredZero).Name).toBe('Ada')
+  })
+
+  it('unwraps New pointers through Indirect', () => {
+    const pointer = New(TypeOf(0))
+    const value = Indirect(pointer)
+
+    expect(value.Int()).toBe(0)
+    value.SetInt(7)
+    expect(pointer.Elem().Int()).toBe(7)
   })
 
   it('interns runtime type descriptors for reflect.Type map keys', () => {

package/gs/reflect/types.ts

@@ -11,6 +11,8 @@ export interface UnsafePointer {
 
 export type Pointer = UnsafePointer | null
 
+export type ReflectFunc = (...args: unknown[]) => unknown
+
 // Define the possible JavaScript values that can be reflected
 export type ReflectValue =
   | null
@@ -20,7 +22,7 @@ export type ReflectValue =
   | bigint
   | string
   | symbol
-  | Function //eslint-disable-line @typescript-eslint/no-unsafe-function-type
+  | ReflectFunc
   | object
   | unknown[]
   | Map<unknown, unknown>
@@ -37,6 +39,10 @@ export type ReflectValue =
 // Import Type and Kind from the main type module
 import { Type, Kind, Value, Kind_String, ChanDir } from './type.js'
 
+type StructFieldInit = Omit<Partial<StructField>, 'Tag'> & {
+  Tag?: StructTag | string
+}
+
 // Struct field representation
 export class StructField {
   public Name: string = ''
@@ -47,9 +53,13 @@ export class StructField {
   public Index: number[] = []
   public Anonymous: boolean = false
 
-  constructor(init?: Partial<StructField>) {
+  constructor(init?: StructFieldInit) {
     if (init) {
-      Object.assign(this, init)
+      const { Tag, ...rest } = init
+      Object.assign(this, rest)
+      if (Tag !== undefined) {
+        this.Tag = typeof Tag === 'string' ? new StructTag(Tag) : Tag
+      }
     }
   }
 
@@ -102,12 +112,17 @@ export function StructTag_Get(tag: StructTag | undefined, key: string): string {
   return tag.Get(key)
 }
 
-// Method representation
-export interface Method {
-  Name: string
-  Type: Type
-  Func: Function //eslint-disable-line @typescript-eslint/no-unsafe-function-type
-  Index: number
+export class Method {
+  public Name = ''
+  public Type!: Type
+  public Func!: ReflectFunc
+  public Index = 0
+
+  constructor(init?: Partial<Method>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
 }
 
 // Channel type for reflection
@@ -139,17 +154,27 @@ export const SelectSend: SelectDir = 1
 export const SelectRecv: SelectDir = 2
 export const SelectDefault: SelectDir = 3
 
-// Slice header (internal representation)
-export interface SliceHeader {
-  Data: uintptr
-  Len: number
-  Cap: number
+export class SliceHeader {
+  public Data: uintptr = 0
+  public Len = 0
+  public Cap = 0
+
+  constructor(init?: Partial<SliceHeader>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
 }
 
-// String header (internal representation)
-export interface StringHeader {
-  Data: uintptr
-  Len: number
+export class StringHeader {
+  public Data: uintptr = 0
+  public Len = 0
+
+  constructor(init?: Partial<StringHeader>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
 }
 
 // Map iterator with proper typing