goscript 0.1.4 → 0.2.0

package/gs/reflect/type.ts

@@ -9,10 +9,9 @@ export { StructField }
 import { MapIter } from './map.js'
 import {
   getTypeByName as builtinGetTypeByName,
-  TypeKind,
   isStructTypeInfo,
   isInterfaceTypeInfo,
-  isStructFieldInfo,
+  structFieldRuntimeKey,
 } from '../builtin/type.js'
 import { Zero } from './value.js'
 import { DeepEqual } from './deepequal.js'
@@ -181,8 +180,13 @@ export const UnsafePointer: Kind = 26
 
 const pointerAddressStride = 0x100000000
 const pointerAddresses = new WeakMap<object, number>()
+const fieldPointerAddresses = new WeakMap<
+  object,
+  globalThis.Map<string, number>
+>()
 let nextPointerAddress = 1
 const canonicalTypes = new globalThis.Map<string, Type>()
+const constructingRegisteredTypes = new globalThis.Map<string, Type>()
 
 function pointerAddress(value: object): number {
   let address = pointerAddresses.get(value)
@@ -194,16 +198,139 @@ function pointerAddress(value: object): number {
   return address
 }
 
+function fieldPointerAddress(target: object, key: string): number {
+  let addresses = fieldPointerAddresses.get(target)
+  if (addresses === undefined) {
+    addresses = new globalThis.Map<string, number>()
+    fieldPointerAddresses.set(target, addresses)
+  }
+  let address = addresses.get(key)
+  if (address === undefined) {
+    address = nextPointerAddress * pointerAddressStride
+    nextPointerAddress++
+    addresses.set(key, address)
+  }
+  return address
+}
+
 function internType(t: Type): Type {
-  const key = `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`
+  const key = typeIdentityKey(t)
   const existing = canonicalTypes.get(key)
   if (existing) {
+    mergeTypeMetadata(existing, t)
     return existing
   }
   canonicalTypes.set(key, t)
   return t
 }
 
+function mergeTypeMetadata(target: Type, source: Type): void {
+  if (target instanceof BasicType && source instanceof BasicType) {
+    target.mergeMethodSignatures(source.methodSignatures())
+    return
+  }
+  if (target instanceof PointerType && source instanceof PointerType) {
+    target.mergeMethodSignatures(source.methodSignatures())
+    return
+  }
+  if (target instanceof FunctionType && source instanceof FunctionType) {
+    target.mergeSignature(source)
+    target.mergeMethodSignatures(source.methodSignatures())
+  }
+}
+
+function typeIdentityKey(t: Type, seen = new Set<Type>()): string {
+  if (seen.has(t)) {
+    return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`
+  }
+  seen.add(t)
+  if (t instanceof StructType) {
+    return t.identityKey(seen)
+  }
+  switch (t.Kind()) {
+    case Array:
+      return `${t.Kind()}:${t.Len()}:${typeIdentityKey(t.Elem(), seen)}`
+    case Chan:
+    case Ptr:
+    case Slice:
+      return `${t.Kind()}:${t.String()}:${typeIdentityKey(t.Elem(), seen)}`
+    case Map:
+      return `${t.Kind()}:${typeIdentityKey(t.Key(), seen)}:${typeIdentityKey(t.Elem(), seen)}`
+    case Func: {
+      if (t.Name() !== '') {
+        return `${t.Kind()}:named:${t.PkgPath()}:${t.Name()}`
+      }
+      const params = globalThis.Array.from(
+        { length: t.NumIn() },
+        (_unused, idx) => typeIdentityKey(t.In(idx), seen),
+      )
+      const results = globalThis.Array.from(
+        { length: t.NumOut() },
+        (_unused, idx) => typeIdentityKey(t.Out(idx), seen),
+      )
+      return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}:${t.IsVariadic()}:${params.join(',')}:${results.join(',')}`
+    }
+    default:
+      return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`
+  }
+}
+
+function typeUnderlyingIdentityKey(t: Type, seen = new Set<Type>()): string {
+  if (seen.has(t)) {
+    return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`
+  }
+  seen.add(t)
+  if (t instanceof BasicType) {
+    return `basic:${t.underlyingName()}`
+  }
+  if (t instanceof StructType) {
+    return t.underlyingIdentityKey(seen)
+  }
+  switch (t.Kind()) {
+    case Array:
+      return `array:${t.Len()}:${typeIdentityKey(t.Elem(), seen)}`
+    case Chan:
+      return `chan:${t.String()}:${typeIdentityKey(t.Elem(), seen)}`
+    case Ptr:
+      return `ptr:${typeIdentityKey(t.Elem(), seen)}`
+    case Slice:
+      return `slice:${typeIdentityKey(t.Elem(), seen)}`
+    case Map:
+      return `map:${typeIdentityKey(t.Key(), seen)}:${typeIdentityKey(
+        t.Elem(),
+        seen,
+      )}`
+    case Func: {
+      const params = globalThis.Array.from(
+        { length: t.NumIn() },
+        (_unused, idx) => typeIdentityKey(t.In(idx), seen),
+      )
+      const results = globalThis.Array.from(
+        { length: t.NumOut() },
+        (_unused, idx) => typeIdentityKey(t.Out(idx), seen),
+      )
+      return `func:${t.IsVariadic()}:${params.join(',')}:${results.join(',')}`
+    }
+    case Interface:
+      return `interface:${typeMethods(t).map(methodSignatureIdentityKey).join('|')}`
+    default:
+      return `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`
+  }
+}
+
+function typeIsNamed(t: Type): boolean {
+  if (t.Kind() === Interface) {
+    return t.String() !== 'interface{}' && !t.String().startsWith('interface {')
+  }
+  if (t.Kind() === Struct || t.Kind() === Func) {
+    return t.Name() !== ''
+  }
+  if (t instanceof BasicType) {
+    return t.Kind() !== Invalid && t.Name() !== ''
+  }
+  return t.Name() !== ''
+}
+
 // Type is the representation of a Go type.
 export interface Type {
   // String returns a string representation of the type.
@@ -222,6 +349,26 @@ export interface Type {
   // NumField returns a struct type's field count.
   NumField(): number
 
+  // NumIn returns a function type's input count.
+  // Panics if the type's Kind is not Func.
+  NumIn(): number
+
+  // In returns a function type's i'th input type.
+  // Panics if the type's Kind is not Func or i is out of range.
+  In(i: number): Type
+
+  // NumOut returns a function type's output count.
+  // Panics if the type's Kind is not Func.
+  NumOut(): number
+
+  // Out returns a function type's i'th output type.
+  // Panics if the type's Kind is not Func or i is out of range.
+  Out(i: number): Type
+
+  // IsVariadic reports whether a function type's final input is variadic.
+  // Panics if the type's Kind is not Func.
+  IsVariadic(): boolean
+
   // PkgPath returns the package path for named types, empty for unnamed types.
   PkgPath(): string
 
@@ -281,6 +428,10 @@ export interface Type {
   Comparable(): boolean
 }
 
+function nonFunctionTypePanic(method: string, t: Type): never {
+  throw new Error(`reflect: ${method} of non-func type ${t.String()}`)
+}
+
 // InvalidTypeInstance is a singleton type for invalid/zero reflect.Value
 class InvalidTypeClass implements Type {
   Kind(): Kind {
@@ -310,6 +461,21 @@ class InvalidTypeClass implements Type {
   NumField(): number {
     return 0
   }
+  NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+  In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+  NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+  Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+  IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
   Field(_i: number): StructField {
     throw new Error('reflect: Field of invalid type')
   }
@@ -476,6 +642,10 @@ export class Value {
   }
 
   public Len(): number {
+    if (this.Kind() === Slice || this.Kind() === Array) {
+      return $.len(this._value as any)
+    }
+
     // Check for slice objects created by $.arrayToSlice
     if (
       this._value &&
@@ -539,8 +709,9 @@ export class Value {
   }
 
   public Index(i: number): Value {
-    if (globalThis.Array.isArray(this._value)) {
-      return new Value(this._value[i], getTypeOf(this._value[i]))
+    if (this.Kind() === Slice || this.Kind() === Array) {
+      const ref = $.indexRef(this._value as any, i) as $.VarRef<ReflectValue>
+      return new Value(ref.value, this._type.Elem(), ref)
     }
     throw new Error(
       'reflect: call of reflect.Value.Index on ' +
@@ -621,17 +792,18 @@ export class Value {
     }
 
     const field = this.Type().Field(i)
+    const fieldKey = structFieldStorageKey(this.Type(), i)
     if (!field) {
       throw new Error('reflect: struct field index out of range')
     }
 
     const parentObj = this._value as Record<string, any>
-    let fieldVal = parentObj[field.Name]
+    let fieldVal = parentObj[fieldKey]
     if (fieldVal === undefined) {
       fieldVal = null
     }
     // Pass parent struct and field name so Set() can update the struct
-    return new Value(fieldVal, field.Type, undefined, parentObj, field.Name)
+    return new Value(fieldVal, field.Type, undefined, parentObj, fieldKey)
   }
 
   public FieldByIndex(index: $.Slice<number>): Value {
@@ -670,6 +842,9 @@ export class Value {
     if (this._value === null || this._value === undefined) {
       return 0
     }
+    if ($.isOwnedPointerHandle(this._value)) {
+      return $.ownedPointerAddress(this._value)
+    }
     if ($.isVarRef(this._value)) {
       const address = this._value.__goAddress?.()
       if (address !== undefined) {
@@ -694,12 +869,26 @@ export class Value {
     return 0
   }
 
-  public UnsafeAddr(): number | { value: Value } {
+  public UnsafeAddr(): number | $.OwnedPointerHandle<ReflectValue> {
     if (!this.CanAddr()) {
       throw new ValueError({ Kind: this.Kind(), Method: 'UnsafeAddr' })
     }
     if (this._parentStruct && this._fieldName) {
-      return { value: this }
+      const target = this._parentStruct
+      const key = this._fieldName
+      const ref = $.fieldRef(
+        target,
+        key as keyof typeof target,
+      ) as $.VarRef<ReflectValue>
+      return {
+        __goOwnedPointer: true,
+        __goAddress: () => fieldPointerAddress(target, key),
+        __goRef: () => ref,
+      }
+    }
+    if (this._parentVarRef?.__goPointer) {
+      return this._parentVarRef
+        .__goPointer as $.OwnedPointerHandle<ReflectValue>
     }
     return this.Pointer()
   }
@@ -735,6 +924,9 @@ export class Value {
     if (this._parentStruct && this._fieldName) {
       return new Value($.fieldRef(this._parentStruct, this._fieldName), ptrType)
     }
+    if (this._parentVarRef) {
+      return new Value(this._parentVarRef, ptrType)
+    }
     return new Value($.varRef(this._value), ptrType)
   }
 
@@ -748,23 +940,9 @@ export class Value {
     if (!this.CanSet()) {
       throw new Error('reflect: assign to invalid value')
     }
-    // Interface types can accept any value
-    if (this.Kind() === Interface) {
-      this._value = x.value
-      // Also update the parent VarRef if we were dereferenced from one
-      if (this._parentVarRef) {
-        this._parentVarRef.value = x.value
-      }
-      // Also update the parent struct field if this is a struct field
-      if (this._parentStruct && this._fieldName) {
-        this._parentStruct[this._fieldName] = x.value
-      }
-      return
-    }
-    // For other types, check if types are compatible (simplified check)
     const thisType = this.Type()
     const xType = x.Type()
-    if (thisType.Kind() !== xType.Kind()) {
+    if (!xType.AssignableTo(thisType)) {
       throw new Error('reflect: assign to wrong type')
     }
     this._value = x.value
@@ -799,22 +977,36 @@ export class Value {
     if (typeof method !== 'function') {
       return new Value()
     }
-    return new Value(method.bind(receiver), new FunctionType('func'))
+    const [signature] = methodSignatureByName(this.Type(), name)
+    const methodType =
+      signature ?
+        methodTypeFromSignature(signature, this.Type(), false)
+      : new FunctionType('func')
+    return new Value(method.bind(receiver), methodType)
   }
 
-  public Call(inArgs: $.Slice<Value>): $.Slice<Value> {
+  public async Call(inArgs: $.Slice<Value>): Promise<$.Slice<Value>> {
     if (this.Kind() !== Func || typeof this._value !== 'function') {
       throw new ValueError({ Kind: this.Kind(), Method: 'Call' })
     }
-    const args = $.asArray(inArgs).map((arg) => arg.Interface())
-    const result = this._value(...args) as ReflectValue | ReflectValue[]
-    if (globalThis.Array.isArray(result)) {
-      return $.arrayToSlice(result.map((value) => ValueOf(value)))
-    }
-    if (result === undefined) {
-      return $.makeSlice<Value>(0)
+    return await callReflectFunction(
+      this._value as (...args: unknown[]) => unknown,
+      this._type,
+      inArgs,
+      'Call',
+    )
+  }
+
+  public async CallSlice(inArgs: $.Slice<Value>): Promise<$.Slice<Value>> {
+    if (this.Kind() !== Func || typeof this._value !== 'function') {
+      throw new ValueError({ Kind: this.Kind(), Method: 'CallSlice' })
     }
-    return $.arrayToSlice([ValueOf(result)])
+    return await callReflectFunction(
+      this._value as (...args: unknown[]) => unknown,
+      this._type,
+      inArgs,
+      'CallSlice',
+    )
   }
 
   public IsZero(): boolean {
@@ -1149,10 +1341,7 @@ export class Value {
   public Cap(): number {
     const k = this.Kind()
     if (k === Slice || k === Array) {
-      if (globalThis.Array.isArray(this._value)) {
-        return this._value.length
-      }
-      return 0
+      return $.cap(this._value as any)
     }
     if (k === Chan) {
       return 0 // Simplified
@@ -1242,6 +1431,7 @@ export class BasicType implements Type {
     private _name: string,
     private _size: number = 8,
     private _typeName: string = '',
+    private _methods: $.MethodSignature[] = [],
   ) {}
 
   public String(): string {
@@ -1252,6 +1442,10 @@ export class BasicType implements Type {
     return this._kind
   }
 
+  public underlyingName(): string {
+    return Kind_String(this._kind)
+  }
+
   public Comparable(): boolean {
     return this._kind !== Func && this._kind !== Map && this._kind !== Slice
   }
@@ -1268,6 +1462,26 @@ export class BasicType implements Type {
     return 0
   }
 
+  public NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+
+  public In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+
+  public NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+
+  public Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+
+  public IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
+
   public PkgPath(): string {
     if (this._typeName) {
       const dotIndex = this._typeName.lastIndexOf('.')
@@ -1315,7 +1529,7 @@ export class BasicType implements Type {
     if (u.Kind() !== Interface) {
       throw new Error('reflect: non-interface type passed to Type.Implements')
     }
-    return false
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -1386,10 +1600,18 @@ export class BasicType implements Type {
   }
 
   public NumMethod(): number {
-    return 0
+    return typeMethods(this).length
   }
-  public MethodByName(_name: string): [Method, boolean] {
-    return [zeroMethod(), false]
+  public MethodByName(name: string): [Method, boolean] {
+    return typeMethodByName(this, name)
+  }
+
+  public methodSignatures(): $.MethodSignature[] {
+    return this._methods
+  }
+
+  public mergeMethodSignatures(methods: $.MethodSignature[]): void {
+    this._methods = mergeMethodSignatureList(this._methods, methods)
   }
 
   public Len(): number {
@@ -1463,6 +1685,26 @@ class SliceType implements Type {
     return 0
   }
 
+  public NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+
+  public In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+
+  public NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+
+  public Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+
+  public IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
+
   public PkgPath(): string {
     return ''
   }
@@ -1497,7 +1739,7 @@ class SliceType implements Type {
     if (u.Kind() !== Interface) {
       throw new Error('reflect: non-interface type passed to Type.Implements')
     }
-    return false
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -1563,6 +1805,26 @@ class ArrayType implements Type {
     return 0
   }
 
+  public NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+
+  public In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+
+  public NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+
+  public Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+
+  public IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
+
   public Len(): number {
     return this._len
   }
@@ -1601,7 +1863,7 @@ class ArrayType implements Type {
     if (u.Kind() !== Interface) {
       throw new Error('reflect: non-interface type passed to Type.Implements')
     }
-    return false
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -1638,7 +1900,10 @@ class ArrayType implements Type {
 
 // Pointer type implementation
 class PointerType implements Type {
-  constructor(private _elemType: Type) {}
+  constructor(
+    private _elemType: Type,
+    private _methods: $.MethodSignature[] = [],
+  ) {}
 
   public String(): string {
     return '*' + this._elemType.String()
@@ -1664,6 +1929,26 @@ class PointerType implements Type {
     return 0
   }
 
+  public NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+
+  public In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+
+  public NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+
+  public Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+
+  public IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
+
   public PkgPath(): string {
     return ''
   }
@@ -1698,9 +1983,7 @@ class PointerType implements Type {
     if (u.Kind() !== Interface) {
       throw new Error('reflect: non-interface type passed to Type.Implements')
     }
-    // For pointer types, check if the element type implements the interface
-    const elemTypeName = this._elemType.String()
-    return typeImplementsInterface(elemTypeName, u)
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -1728,10 +2011,18 @@ class PointerType implements Type {
   }
 
   public NumMethod(): number {
-    return 0
+    return typeMethods(this).length
   }
   public MethodByName(name: string): [Method, boolean] {
-    return typeMethodByName(this._elemType, name)
+    return typeMethodByName(this, name)
+  }
+
+  public methodSignatures(): $.MethodSignature[] {
+    return this._methods
+  }
+
+  public mergeMethodSignatures(methods: $.MethodSignature[]): void {
+    this._methods = mergeMethodSignatureList(this._methods, methods)
   }
 
   public Len(): number {
@@ -1744,10 +2035,54 @@ class PointerType implements Type {
 }
 
 // Function type implementation
+interface FunctionTypeDescriptor {
+  name?: string
+  signature?: string
+  params?: Type[]
+  results?: Type[]
+  variadic?: boolean
+  methods?: $.MethodSignature[]
+}
+
 class FunctionType implements Type {
-  constructor(private _signature: string) {}
+  private _name: string
+  private _signature: string
+  private _params: Type[]
+  private _results: Type[]
+  private _variadic: boolean
+  private _hasSignature: boolean
+  private _methods: $.MethodSignature[]
+
+  constructor(signatureOrDescriptor: string | FunctionTypeDescriptor) {
+    if (typeof signatureOrDescriptor === 'string') {
+      this._name = ''
+      this._signature = signatureOrDescriptor
+      this._params = []
+      this._results = []
+      this._variadic = false
+      this._hasSignature = false
+      this._methods = []
+      return
+    }
+
+    this._name = signatureOrDescriptor.name ?? ''
+    this._params = signatureOrDescriptor.params ?? []
+    this._results = signatureOrDescriptor.results ?? []
+    this._variadic = signatureOrDescriptor.variadic ?? false
+    this._hasSignature =
+      signatureOrDescriptor.signature !== undefined ||
+      signatureOrDescriptor.params !== undefined ||
+      signatureOrDescriptor.results !== undefined
+    this._methods = signatureOrDescriptor.methods ?? []
+    this._signature =
+      signatureOrDescriptor.signature ??
+      formatFunctionSignature(this._params, this._results, this._variadic)
+  }
 
   public String(): string {
+    if (this._name !== '') {
+      return this._name
+    }
     return this._signature
   }
 
@@ -1771,12 +2106,54 @@ class FunctionType implements Type {
     return 0
   }
 
+  public NumIn(): number {
+    return this._params.length
+  }
+
+  public In(i: number): Type {
+    if (i < 0 || i >= this._params.length) {
+      throw new Error(
+        `reflect: In index out of range [${i}] with length ${this._params.length}`,
+      )
+    }
+    return this._params[i]
+  }
+
+  public NumOut(): number {
+    return this._results.length
+  }
+
+  public Out(i: number): Type {
+    if (i < 0 || i >= this._results.length) {
+      throw new Error(
+        `reflect: Out index out of range [${i}] with length ${this._results.length}`,
+      )
+    }
+    return this._results[i]
+  }
+
+  public IsVariadic(): boolean {
+    return this._variadic
+  }
+
   public PkgPath(): string {
+    if (this._name !== '') {
+      const dotIndex = this._name.lastIndexOf('.')
+      if (dotIndex > 0) {
+        return this._name.substring(0, dotIndex)
+      }
+    }
     return ''
   }
 
   public Name(): string {
-    // Function types are unnamed composite types
+    if (this._name !== '') {
+      const dotIndex = this._name.lastIndexOf('.')
+      if (dotIndex >= 0) {
+        return this._name.substring(dotIndex + 1)
+      }
+      return this._name
+    }
     return ''
   }
 
@@ -1805,7 +2182,7 @@ class FunctionType implements Type {
     if (u.Kind() !== Interface) {
       throw new Error('reflect: non-interface type passed to Type.Implements')
     }
-    return false
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -1829,10 +2206,29 @@ class FunctionType implements Type {
   }
 
   public NumMethod(): number {
-    return 0
+    return typeMethods(this).length
   }
-  public MethodByName(_name: string): [Method, boolean] {
-    return [zeroMethod(), false]
+  public MethodByName(name: string): [Method, boolean] {
+    return typeMethodByName(this, name)
+  }
+
+  public methodSignatures(): $.MethodSignature[] {
+    return this._methods
+  }
+
+  public mergeMethodSignatures(methods: $.MethodSignature[]): void {
+    this._methods = mergeMethodSignatureList(this._methods, methods)
+  }
+
+  public mergeSignature(source: FunctionType): void {
+    if (!source._hasSignature || this._hasSignature) {
+      return
+    }
+    this._params = source._params
+    this._results = source._results
+    this._variadic = source._variadic
+    this._signature = source._signature
+    this._hasSignature = true
   }
 
   public Len(): number {
@@ -1844,72 +2240,329 @@ class FunctionType implements Type {
   }
 }
 
-// Map type implementation
-class MapType implements Type {
-  constructor(
-    private _keyType: Type,
-    private _elemType: Type,
-  ) {}
-
-  public String(): string {
-    return `map[${this._keyType.String()}]${this._elemType.String()}`
+function formatFunctionSignature(
+  params: Type[],
+  results: Type[],
+  variadic: boolean,
+): string {
+  const paramStrings = params.map((param, index) => {
+    const typeName = param.String()
+    if (!variadic || index !== params.length - 1) {
+      return typeName
+    }
+    if (typeName.startsWith('[]')) {
+      return '...' + typeName.slice(2)
+    }
+    return '...' + typeName
+  })
+  let signature = `func(${paramStrings.join(', ')})`
+  if (results.length === 1) {
+    signature += ` ${results[0].String()}`
+  } else if (results.length > 1) {
+    signature += ` (${results.map((result) => result.String()).join(', ')})`
   }
+  return signature
+}
 
-  public Kind(): Kind {
-    return Map
-  }
+async function callReflectFunction(
+  fn: (...args: unknown[]) => unknown | Promise<unknown>,
+  fnType: Type,
+  inArgs: $.Slice<Value>,
+  op: ReflectCallOp,
+): Promise<$.Slice<Value>> {
+  const args = $.asArray(inArgs)
+  const rawArgs = reflectCallRawArgs(fnType, args, op)
+  const result = await fn(...rawArgs)
+  return normalizeReflectCallResults(fnType, result)
+}
 
-  public Comparable(): boolean {
-    return false
-  }
+type ReflectCallOp = 'Call' | 'CallSlice'
 
-  public Size(): number {
-    return 8 // map header size
+function reflectCallRawArgs(
+  fnType: Type,
+  args: Value[],
+  op: ReflectCallOp,
+): unknown[] {
+  if (op === 'CallSlice') {
+    return reflectCallSliceRawArgs(fnType, args)
   }
-
-  public Elem(): Type {
-    return this._elemType
+  if (!fnType.IsVariadic()) {
+    validateReflectCallInputCount(fnType, args.length)
+    return args.map((arg, index) =>
+      reflectCallValueInterface(op, arg, fnType.In(index), index),
+    )
   }
-
-  public NumField(): number {
-    return 0
+  const fixedCount = fnType.NumIn() - 1
+  if (args.length < fixedCount) {
+    throw new Error('reflect: Call with too few input arguments')
   }
-
-  public Key(): Type {
-    return this._keyType
+  const rawArgs: unknown[] = []
+  for (let i = 0; i < fixedCount; i++) {
+    rawArgs.push(reflectCallValueInterface(op, args[i], fnType.In(i), i))
   }
-
-  public PkgPath(): string {
-    return ''
+  const variadicElemType = fnType.In(fixedCount).Elem()
+  const variadicValues = args.slice(fixedCount)
+  for (let i = 0; i < variadicValues.length; i++) {
+    const value = variadicValues[i]
+    if (!value.IsValid()) {
+      throw new Error(`reflect: ${op} using zero Value argument`)
+    }
+    if (!value.Type().AssignableTo(variadicElemType)) {
+      throw new Error(
+        `reflect: cannot use ${value.Type().String()} as type ${variadicElemType.String()} in ${op}`,
+      )
+    }
   }
+  rawArgs.push($.arrayToSlice(variadicValues.map((value) => value.Interface())))
+  return rawArgs
+}
 
-  public Name(): string {
-    // Map types are unnamed composite types
-    return ''
+function reflectCallSliceRawArgs(fnType: Type, args: Value[]): unknown[] {
+  if (!fnType.IsVariadic()) {
+    throw new Error('reflect: CallSlice of non-variadic function')
   }
-
-  public Field(_i: number): StructField {
-    throw new Error('reflect: Field of non-struct type')
+  const expected = fnType.NumIn()
+  if (args.length < expected) {
+    throw new Error('reflect: CallSlice with too few input arguments')
+  }
+  if (args.length > expected) {
+    throw new Error('reflect: CallSlice with too many input arguments')
   }
+  return args.map((arg, index) =>
+    reflectCallValueInterface('CallSlice', arg, fnType.In(index), index),
+  )
+}
 
-  public FieldByName(name: string): [StructField, boolean] {
-    return typeFieldByName(this, name)
+function reflectCallValueInterface(
+  op: ReflectCallOp,
+  value: Value,
+  target: Type,
+  _index: number,
+): unknown {
+  if (!value.IsValid()) {
+    throw new Error(`reflect: ${op} using zero Value argument`)
   }
+  if (!value.Type().AssignableTo(target)) {
+    throw new Error(
+      `reflect: ${op} using ${value.Type().String()} as type ${target.String()}`,
+    )
+  }
+  return value.Interface()
+}
 
-  public FieldByNameFunc(
-    match: (name: string) => boolean,
-  ): [StructField, boolean] {
-    return typeFieldByNameFunc(this, match)
+function validateReflectCallInputCount(fnType: Type, actual: number): void {
+  const expected = fnType.NumIn()
+  if (actual !== expected) {
+    throw new Error(
+      `reflect: Call with ${actual} input arguments for function with ${expected} inputs`,
+    )
   }
+}
 
-  public Implements(u: Type | null): boolean {
-    if (!u) {
-      return false
-    }
-    if (u.Kind() !== Interface) {
-      throw new Error('reflect: non-interface type passed to Type.Implements')
+function normalizeReflectCallResults(
+  fnType: Type,
+  result: unknown,
+): $.Slice<Value> {
+  const expected = fnType.NumOut()
+  if (expected === 0) {
+    if (result !== undefined) {
+      throw new Error(
+        'reflect: Call returned 1 results for function with 0 outputs',
+      )
     }
-    return false
+    return $.makeSlice<Value>(0)
+  }
+  if (expected === 1) {
+    return $.arrayToSlice([new Value(result as ReflectValue, fnType.Out(0))])
+  }
+  if (!globalThis.Array.isArray(result)) {
+    throw new Error(
+      `reflect: Call returned 1 results for function with ${expected} outputs`,
+    )
+  }
+  if (result.length !== expected) {
+    throw new Error(
+      `reflect: Call returned ${result.length} results for function with ${expected} outputs`,
+    )
+  }
+  return $.arrayToSlice(
+    result.map(
+      (value, index) => new Value(value as ReflectValue, fnType.Out(index)),
+    ),
+  )
+}
+
+export function MakeFunc(
+  typ: Type | null,
+  fn:
+    | ((args: $.Slice<Value>) => $.Slice<Value> | Promise<$.Slice<Value>>)
+    | null,
+): Value {
+  if (!typ || typ.Kind() !== Func) {
+    throw new Error('reflect: call of MakeFunc with non-Func type')
+  }
+  if (typeof fn !== 'function') {
+    throw new Error('reflect.MakeFunc: nil implementation')
+  }
+  const typeInfo = functionTypeInfoFromType(typ)
+  const wrapper = $.functionValue(async (...rawArgs: unknown[]) => {
+    const args = makeFuncArgs(typ, rawArgs)
+    const resultValues = $.asArray(await fn($.arrayToSlice(args)))
+    validateMakeFuncResults(typ, resultValues)
+    if (typ.NumOut() === 0) {
+      return undefined
+    }
+    if (typ.NumOut() === 1) {
+      return makeFuncReturnInterface(resultValues[0], typ.Out(0))
+    }
+    return resultValues.map((value, index) =>
+      makeFuncReturnInterface(value, typ.Out(index)),
+    )
+  }, typeInfo)
+  return new Value(wrapper, typ)
+}
+
+function makeFuncArgs(typ: Type, rawArgs: unknown[]): Value[] {
+  validateReflectCallInputCount(typ, rawArgs.length)
+  return rawArgs.map((arg, index) => {
+    const value = ValueOf(arg as ReflectValue)
+    const target = typ.In(index)
+    if (!value.Type().AssignableTo(target)) {
+      throw new Error(
+        `reflect.MakeFunc: cannot use ${value.Type().String()} as type ${target.String()} in argument ${index}`,
+      )
+    }
+    return value
+  })
+}
+
+function validateMakeFuncResults(typ: Type, resultValues: Value[]): void {
+  const expected = typ.NumOut()
+  if (resultValues.length !== expected) {
+    throw new Error(
+      `reflect.MakeFunc: returned ${resultValues.length} results for function with ${expected} outputs`,
+    )
+  }
+  for (let i = 0; i < resultValues.length; i++) {
+    const result = resultValues[i]
+    if (!result.IsValid()) {
+      throw new Error(`reflect.MakeFunc: returned zero Value for result ${i}`)
+    }
+    const target = typ.Out(i)
+    if (!result.Type().AssignableTo(target)) {
+      throw new Error(
+        `reflect.MakeFunc: cannot use ${result.Type().String()} as type ${target.String()} in result ${i}`,
+      )
+    }
+  }
+}
+
+function makeFuncReturnInterface(value: Value, target: Type): unknown {
+  const raw = value.Interface()
+  if (target.Kind() === Interface) {
+    return raw
+  }
+  return unwrapGoInterfaceBox(raw)
+}
+
+function unwrapGoInterfaceBox(value: unknown): unknown {
+  if (
+    value !== null &&
+    value !== undefined &&
+    typeof value === 'object' &&
+    '__goValue' in value
+  ) {
+    return (value as { __goValue: unknown }).__goValue
+  }
+  return value
+}
+
+// Map type implementation
+class MapType implements Type {
+  constructor(
+    private _keyType: Type,
+    private _elemType: Type,
+  ) {}
+
+  public String(): string {
+    return `map[${this._keyType.String()}]${this._elemType.String()}`
+  }
+
+  public Kind(): Kind {
+    return Map
+  }
+
+  public Comparable(): boolean {
+    return false
+  }
+
+  public Size(): number {
+    return 8 // map header size
+  }
+
+  public Elem(): Type {
+    return this._elemType
+  }
+
+  public NumField(): number {
+    return 0
+  }
+
+  public NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+
+  public In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+
+  public NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+
+  public Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+
+  public IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
+
+  public Key(): Type {
+    return this._keyType
+  }
+
+  public PkgPath(): string {
+    return ''
+  }
+
+  public Name(): string {
+    // Map types are unnamed composite types
+    return ''
+  }
+
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type')
+  }
+
+  public FieldByName(name: string): [StructField, boolean] {
+    return typeFieldByName(this, name)
+  }
+
+  public FieldByNameFunc(
+    match: (name: string) => boolean,
+  ): [StructField, boolean] {
+    return typeFieldByNameFunc(this, match)
+  }
+
+  public Implements(u: Type | null): boolean {
+    if (!u) {
+      return false
+    }
+    if (u.Kind() !== Interface) {
+      throw new Error('reflect: non-interface type passed to Type.Implements')
+    }
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -1949,61 +2602,174 @@ class MapType implements Type {
 }
 
 // Struct type implementation
-/**
- * Helper function to check if a type's method set contains all methods
- * required by an interface.
- *
- * @param typeName The name of the type to check (e.g., "main.MyType")
- * @param interfaceType The interface type that must be implemented
- * @returns True if the type implements the interface, false otherwise
- */
-function typeImplementsInterface(
-  typeName: string,
-  interfaceType: Type,
-): boolean {
-  // Get the interface name and look it up in the type registry
-  const interfaceName =
-    interfaceType instanceof InterfaceType ?
-      interfaceType.registeredName() || interfaceType.String()
-    : interfaceType.String()
-  const interfaceTypeInfo = builtinGetTypeByName(interfaceName)
-
-  if (!interfaceTypeInfo || !isInterfaceTypeInfo(interfaceTypeInfo)) {
-    return false
+function typeImplementsInterface(t: Type, interfaceType: Type): boolean {
+  if (interfaceType.Kind() !== Interface) {
+    throw new Error('reflect: non-interface type passed to Type.Implements')
+  }
+  const requiredMethods = typeMethods(interfaceType)
+  if (requiredMethods.length === 0) {
+    return true
   }
+  const methods = typeMethods(t)
+  return requiredMethods.every((requiredMethod) => {
+    const method = methods.find(
+      (candidate) => candidate.name === requiredMethod.name,
+    )
+    return (
+      method !== undefined && methodSignatureIdentical(method, requiredMethod)
+    )
+  })
+}
 
-  // Get the type info for the struct/type
-  const typeInfo = builtinGetTypeByName(typeName)
+function methodSignatureIdentical(
+  actual: $.MethodSignature,
+  required: $.MethodSignature,
+): boolean {
+  return (
+    methodArgListIdentical(actual.args, required.args) &&
+    methodArgListIdentical(actual.returns, required.returns)
+  )
+}
 
-  if (!typeInfo || !isStructTypeInfo(typeInfo)) {
+function methodArgListIdentical(
+  actual: $.MethodArg[],
+  required: $.MethodArg[],
+): boolean {
+  if (actual.length !== required.length) {
     return false
   }
+  return actual.every(
+    (arg, index) =>
+      methodArgIdentityKey(arg) === methodArgIdentityKey(required[index]),
+  )
+}
 
-  // Check if the type has all required methods
-  const requiredMethods = interfaceTypeInfo.methods || []
-  const typeMethods = typeInfo.methods || []
+function methodArgIdentityKey(arg: $.MethodArg): string {
+  return typeInfoIdentityKey(arg.type, new Set())
+}
 
-  // For each required method, check if the type has a matching method
-  for (const requiredMethod of requiredMethods) {
-    const typeMethod = typeMethods.find((m) => m.name === requiredMethod.name)
+function methodSignatureIdentityKey(method: $.MethodSignature): string {
+  const args = method.args.map(methodArgIdentityKey).join(',')
+  const returns = method.returns.map(methodArgIdentityKey).join(',')
+  return `${method.name}(${args})(${returns})`
+}
 
-    if (!typeMethod) {
-      return false
+function mergeMethodSignatureList(
+  existing: $.MethodSignature[],
+  incoming: $.MethodSignature[],
+): $.MethodSignature[] {
+  if (incoming.length === 0) {
+    return existing
+  }
+  const merged = [...existing]
+  for (const method of incoming) {
+    const existingIndex = merged.findIndex(
+      (candidate) => candidate.name === method.name,
+    )
+    if (existingIndex === -1) {
+      merged.push(method)
+      continue
     }
-
-    // Check if method signatures match (simplified - just check counts)
-    if (typeMethod.args.length !== requiredMethod.args.length) {
-      return false
+    if (
+      methodSignatureIdentityKey(merged[existingIndex]) !==
+      methodSignatureIdentityKey(method)
+    ) {
+      merged[existingIndex] = method
     }
+  }
+  return merged.sort((left, right) => left.name.localeCompare(right.name))
+}
 
-    if (typeMethod.returns.length !== requiredMethod.returns.length) {
-      return false
+function typeInfoIdentityKey(
+  info: $.TypeInfo | string,
+  seen: Set<string>,
+): string {
+  if (typeof info === 'string') {
+    const registered = builtinGetTypeByName(info)
+    if (!registered) {
+      return `named:${info}`
     }
-
-    // Could add deeper type checking here, but for now this is sufficient
+    const registeredName = registered.name ?? info
+    if (registeredName !== '') {
+      return `named:${registeredName}`
+    }
+    if (seen.has(info)) {
+      return `named:${info}`
+    }
+    seen.add(info)
+    const key = typeInfoIdentityKey(registered, seen)
+    seen.delete(info)
+    return key
+  }
+  switch (info.kind) {
+    case $.TypeKind.Basic:
+      if (info.typeName) {
+        return `named:${info.typeName}`
+      }
+      return `basic:${info.name ?? 'unknown'}`
+    case $.TypeKind.Interface:
+      if (info.name) {
+        return `named:${info.name}`
+      }
+      return `interface:${(info.methods ?? [])
+        .map(methodSignatureIdentityKey)
+        .join('|')}`
+    case $.TypeKind.Struct:
+      if (info.name) {
+        return `named:${info.name}`
+      }
+      return `struct:${(info.fields ?? [])
+        .map(
+          (field) =>
+            [
+              field.name,
+              field.pkgPath ?? '',
+              field.tag ?? '',
+              field.anonymous === true ? 'anonymous' : 'named',
+              typeInfoIdentityKey(field.type, seen),
+            ].join('\u0000'),
+        )
+        .join('\u0001')}`
+    case $.TypeKind.Pointer:
+      return `ptr:${typeInfoIdentityKey(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    case $.TypeKind.Slice:
+      return `slice:${typeInfoIdentityKey(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    case $.TypeKind.Array:
+      return `array:${info.length}:${typeInfoIdentityKey(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    case $.TypeKind.Map:
+      return `map:${typeInfoIdentityKey(
+        info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}:${typeInfoIdentityKey(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    case $.TypeKind.Function:
+      if (info.name) {
+        return `named:${info.name}`
+      }
+      return `func:${info.isVariadic === true}:${(info.params ?? [])
+        .map((param) => typeInfoIdentityKey(param, seen))
+        .join(',')}:${(info.results ?? [])
+        .map((result) => typeInfoIdentityKey(result, seen))
+        .join(',')}`
+    case $.TypeKind.Channel:
+      return `chan:${info.direction ?? 'both'}:${typeInfoIdentityKey(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    default:
+      return 'unknown'
   }
-
-  return true
 }
 
 function typeFieldByName(t: Type, name: string): [StructField, boolean] {
@@ -2017,8 +2783,7 @@ function typeFieldByNameFunc(
   if (t.Kind() !== Struct) {
     throw new Error('reflect: FieldByName of non-struct type')
   }
-  for (let i = 0; i < t.NumField(); i++) {
-    const field = t.Field(i)
+  for (const field of visibleStructFields(t)) {
     if (match(field.Name)) {
       return [field, true]
     }
@@ -2026,6 +2791,59 @@ function typeFieldByNameFunc(
   return [new StructField(), false]
 }
 
+export function visibleStructFields(t: Type): StructField[] {
+  const fields: StructField[] = []
+  const byName = new globalThis.Map<string, number>()
+  const visiting = new Set<Type>()
+  const index: number[] = []
+
+  const walk = (typ: Type): void => {
+    if (visiting.has(typ)) {
+      return
+    }
+    visiting.add(typ)
+    for (let i = 0; i < typ.NumField(); i++) {
+      const field = typ.Field(i).clone()
+      index.push(i)
+
+      let add = true
+      const oldIndex = byName.get(field.Name)
+      if (oldIndex !== undefined) {
+        const old = fields[oldIndex]
+        if (index.length === old.Index.length) {
+          old.Name = ''
+          add = false
+        } else if (index.length < old.Index.length) {
+          old.Name = ''
+        } else {
+          add = false
+        }
+      }
+      if (add) {
+        field.Index = [...index]
+        byName.set(field.Name, fields.length)
+        fields.push(field)
+      }
+
+      if (field.Anonymous) {
+        let fieldType = field.Type
+        if (fieldType.Kind() === Ptr) {
+          fieldType = fieldType.Elem()
+        }
+        if (fieldType.Kind() === Struct) {
+          walk(fieldType)
+        }
+      }
+
+      index.pop()
+    }
+    visiting.delete(typ)
+  }
+
+  walk(t)
+  return fields.filter((field) => field.Name !== '')
+}
+
 function zeroMethod(): Method {
   return {
     Name: '',
@@ -2038,17 +2856,65 @@ function zeroMethod(): Method {
 function methodFromSignature(
   signature: $.MethodSignature,
   index: number,
+  receiver: Type,
 ): Method {
   return {
     Name: signature.name,
-    Type: new FunctionType('func'),
+    Type: methodTypeFromSignature(
+      signature,
+      receiver,
+      receiver.Kind() !== Interface,
+    ),
     Func: () => undefined,
     Index: index,
   }
 }
 
+function methodTypeFromSignature(
+  signature: $.MethodSignature,
+  receiver: Type,
+  includeReceiver: boolean,
+): Type {
+  const params = signature.args.map(methodArgType)
+  if (includeReceiver) {
+    params.unshift(receiver)
+  }
+  return new FunctionType({
+    params,
+    results: signature.returns.map(methodArgType),
+  })
+}
+
+function methodArgType(arg: $.MethodArg): Type {
+  return typeFromTypeInfoWithSeen(arg.type, new Set())
+}
+
 function typeMethods(t: Type): $.MethodSignature[] {
-  const typeInfo = builtinGetTypeByName(t.String())
+  let typeInfo = builtinGetTypeByName(t.String())
+  if (!typeInfo && t.Kind() === Ptr) {
+    typeInfo = builtinGetTypeByName(t.Elem().String())
+  }
+  if (!typeInfo && t instanceof InterfaceType) {
+    const registeredName = t.registeredName()
+    if (registeredName) {
+      typeInfo = builtinGetTypeByName(registeredName)
+    }
+  }
+  if (!typeInfo && t instanceof InterfaceType) {
+    return t.methodSignatures()
+  }
+  if (!typeInfo && t instanceof PointerType) {
+    return mergeMethodSignatureList(
+      typeMethods(t.Elem()),
+      t.methodSignatures(),
+    )
+  }
+  if (!typeInfo && t instanceof BasicType) {
+    return t.methodSignatures()
+  }
+  if (!typeInfo && t instanceof FunctionType) {
+    return t.methodSignatures()
+  }
   if (!typeInfo) {
     return []
   }
@@ -2058,30 +2924,119 @@ function typeMethods(t: Type): $.MethodSignature[] {
   return []
 }
 
-function typeMethodByName(t: Type, name: string): [Method, boolean] {
+function methodSignatureByName(
+  t: Type,
+  name: string,
+): [$.MethodSignature | undefined, number] {
   const methods = typeMethods(t)
   const index = methods.findIndex((method) => method.name === name)
   if (index === -1) {
+    return [undefined, -1]
+  }
+  return [methods[index], index]
+}
+
+function typeMethodByName(t: Type, name: string): [Method, boolean] {
+  const [signature, index] = methodSignatureByName(t, name)
+  if (!signature) {
     return [zeroMethod(), false]
   }
-  return [methodFromSignature(methods[index], index), true]
+  return [methodFromSignature(signature, index, t), true]
 }
 
 function typeAssignableTo(t: Type, u: Type | null): boolean {
   if (u === null) {
     return false
   }
-  return t.String() === u.String() || t.Implements(u)
+  if (typeIdentityKey(t) === typeIdentityKey(u)) {
+    return true
+  }
+  if (
+    (!typeIsNamed(t) || !typeIsNamed(u)) &&
+    typeUnderlyingIdentityKey(t) === typeUnderlyingIdentityKey(u)
+  ) {
+    return true
+  }
+  if (u.Kind() !== Interface) {
+    return false
+  }
+  return t.Implements(u)
+}
+
+export function structFieldStorageKey(t: Type, i: number): string {
+  if (t instanceof StructType) {
+    return t.fieldKey(i)
+  }
+  return t.Field(i).Name
+}
+
+interface StructFieldDescriptor {
+  name: string
+  key: string
+  type: Type
+  tag?: string
+  pkgPath: string
+  anonymous: boolean
+  index: number[]
+  offset: number
+  exported: boolean
+}
+
+function typeAlignment(typ: Type): number {
+  switch (typ.Kind()) {
+    case Bool:
+    case Int8:
+    case Uint8:
+      return 1
+    case Int16:
+    case Uint16:
+      return 2
+    case Int32:
+    case Uint32:
+    case Float32:
+    case Complex64:
+      return 4
+    case Array:
+      return typeAlignment(typ.Elem())
+    case Struct: {
+      let align = 1
+      for (let i = 0; i < typ.NumField(); i++) {
+        align = Math.max(align, typeAlignment(typ.Field(i).Type))
+      }
+      return align
+    }
+    default:
+      return 8
+  }
+}
+
+function alignOffset(offset: number, alignment: number): number {
+  if (alignment <= 1) {
+    return offset
+  }
+  return Math.ceil(offset / alignment) * alignment
+}
+
+function structDescriptorSize(fields: StructFieldDescriptor[]): number {
+  let size = 0
+  let alignment = 1
+  for (const field of fields) {
+    alignment = Math.max(alignment, typeAlignment(field.type))
+    size = Math.max(size, field.offset + field.type.Size())
+  }
+  return alignOffset(size, alignment)
 }
 
 class StructType implements Type {
   constructor(
     private _name: string,
-    private _fields: Array<{ name: string; type: Type; tag?: string }> = [],
+    private _fields: StructFieldDescriptor[] = [],
+    private _pkgPath = '',
+    private _string = _name,
   ) {}
 
   public String(): string {
-    return this._name
+    return this._string
   }
 
   public Kind(): Kind {
@@ -2093,8 +3048,7 @@ class StructType implements Type {
   }
 
   public Size(): number {
-    // Struct size is implementation-defined, we'll use a reasonable default
-    return this._fields.reduce((sum, field) => sum + field.type.Size(), 0)
+    return structDescriptorSize(this._fields)
   }
 
   public Elem(): Type {
@@ -2105,7 +3059,33 @@ class StructType implements Type {
     return this._fields.length
   }
 
+  public NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+
+  public In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+
+  public NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+
+  public Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+
+  public IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
+
   public PkgPath(): string {
+    if (this._pkgPath !== '') {
+      return this._pkgPath
+    }
+    if (this._name === '') {
+      return ''
+    }
     // Extract package path from full type name (e.g., "main.Person" -> "main")
     const dotIndex = this._name.lastIndexOf('.')
     if (dotIndex > 0) {
@@ -2115,6 +3095,9 @@ class StructType implements Type {
   }
 
   public Name(): string {
+    if (this._name === '') {
+      return ''
+    }
     // Extract type name from full type name (e.g., "main.Person" -> "Person")
     const dotIndex = this._name.lastIndexOf('.')
     if (dotIndex >= 0) {
@@ -2132,13 +3115,68 @@ class StructType implements Type {
     const f = this._fields[i]
     return new StructField({
       Name: f.name,
-      PkgPath: '',
+      PkgPath: f.pkgPath,
       Type: f.type,
       Tag: f.tag ? new StructTag(f.tag) : undefined,
-      Index: [i],
+      Offset: f.offset,
+      Index: [...f.index],
+      Anonymous: f.anonymous,
     })
   }
 
+  public fieldKey(i: number): string {
+    if (i < 0 || i >= this.NumField()) {
+      throw new Error(
+        `reflect: Field index out of range [${i}] with length ${this.NumField()}`,
+      )
+    }
+    return this._fields[i].key
+  }
+
+  public descriptors(): StructFieldDescriptor[] {
+    return this._fields.map((field) => ({
+      ...field,
+      index: [...field.index],
+    }))
+  }
+
+  public replaceDescriptors(fields: StructFieldDescriptor[]): void {
+    this._fields = fields
+  }
+
+  public identityKey(seen: Set<Type>): string {
+    if (this._name !== '') {
+      return `struct:${this._name}`
+    }
+    const fields = this._fields
+      .map((field) =>
+        [
+          field.name,
+          field.pkgPath,
+          field.tag ?? '',
+          field.anonymous ? 'anonymous' : 'named',
+          typeIdentityKey(field.type, seen),
+        ].join('\u0000'),
+      )
+      .join('\u0001')
+    return `struct:${this._pkgPath}:${this._name}:${fields}`
+  }
+
+  public underlyingIdentityKey(seen: Set<Type>): string {
+    const fields = this._fields
+      .map((field) =>
+        [
+          field.name,
+          field.pkgPath,
+          field.tag ?? '',
+          field.anonymous ? 'anonymous' : 'named',
+          typeIdentityKey(field.type, seen),
+        ].join('\u0000'),
+      )
+      .join('\u0001')
+    return `struct:${fields}`
+  }
+
   public FieldByName(name: string): [StructField, boolean] {
     return typeFieldByName(this, name)
   }
@@ -2160,7 +3198,7 @@ class StructType implements Type {
     if (u.Kind() !== Interface) {
       throw new Error('reflect: non-interface type passed to Type.Implements')
     }
-    return typeImplementsInterface(this._name, u)
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -2201,7 +3239,7 @@ class StructType implements Type {
     throw new Error('reflect: call of reflect.Type.Bits on struct Type')
   }
 
-  static createTypeFromFieldInfo(ti: any): Type {
+  static createTypeFromFieldInfo(ti: any, seen = new Set<string>()): Type {
     if (typeof ti === 'string') {
       return basicTypeFromName(ti === 'number' ? 'int' : ti)
     } else if (ti && ti.kind) {
@@ -2214,21 +3252,29 @@ class StructType implements Type {
         case 'slice':
           if (ti.elemType) {
             return new SliceType(
-              StructType.createTypeFromFieldInfo(ti.elemType),
+              StructType.createTypeFromFieldInfo(ti.elemType, seen),
             )
           }
           return new SliceType(new BasicType(Invalid, 'unknown', 8))
         case 'pointer':
           if (ti.elemType) {
             return new PointerType(
-              StructType.createTypeFromFieldInfo(ti.elemType),
+              StructType.createTypeFromFieldInfo(ti.elemType, seen),
             )
           }
           return new PointerType(new BasicType(Invalid, 'unknown', 8))
         case 'interface':
-          return new InterfaceType(name)
-        case 'struct':
-          return new StructType(name, structFieldsFromTypeInfo(ti))
+          return interfaceTypeFromInfo(ti, seen)
+        case 'struct': {
+          const structName = ti.name ?? ''
+          const fields = structFieldsFromTypeInfo(ti, seen)
+          return new StructType(
+            structName,
+            fields,
+            '',
+            structName === '' ? structTypeString(fields) : structName,
+          )
+        }
         default:
           return new BasicType(Invalid, name, 8)
       }
@@ -2282,18 +3328,19 @@ function basicTypeFromName(name: string, typeName = ''): BasicType {
 
 function structFieldsFromTypeInfo(
   ti: $.StructTypeInfo,
-): Array<{ name: string; type: Type; tag?: string }> {
-  return Object.entries(ti.fields || {}).map(([name, fieldInfo]) => {
-    if (isStructFieldInfo(fieldInfo)) {
-      return {
-        name: fieldInfo.name ?? name,
-        type: typeFromTypeInfo(fieldInfo.type),
-        tag: fieldInfo.tag,
-      }
-    }
+  seen = new Set<string>(),
+): StructFieldDescriptor[] {
+  return (ti.fields || []).map((fieldInfo, index) => {
     return {
-      name,
-      type: typeFromTypeInfo(fieldInfo),
+      name: fieldInfo.name,
+      key: structFieldRuntimeKey(fieldInfo),
+      type: typeFromTypeInfoWithSeen(fieldInfo.type, seen),
+      tag: fieldInfo.tag,
+      pkgPath: fieldInfo.pkgPath ?? '',
+      anonymous: fieldInfo.anonymous ?? false,
+      index: fieldInfo.index ? [...fieldInfo.index] : [index],
+      offset: fieldInfo.offset ?? index * 8,
+      exported: fieldInfo.exported ?? (fieldInfo.pkgPath ?? '') === '',
     }
   })
 }
@@ -2339,6 +3386,26 @@ class ChannelType implements Type {
     return 0
   }
 
+  public NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+
+  public In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+
+  public NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+
+  public Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+
+  public IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
+
   public PkgPath(): string {
     return ''
   }
@@ -2373,7 +3440,7 @@ class ChannelType implements Type {
     if (u.Kind() !== Interface) {
       throw new Error('reflect: non-interface type passed to Type.Implements')
     }
-    return false
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -2421,6 +3488,7 @@ class InterfaceType implements Type {
   constructor(
     private _name: string = 'interface{}',
     private _registeredName?: string,
+    private _methods: $.MethodSignature[] = [],
   ) {}
 
   public String(): string {
@@ -2447,6 +3515,26 @@ class InterfaceType implements Type {
     return 0
   }
 
+  public NumIn(): number {
+    return nonFunctionTypePanic('NumIn', this)
+  }
+
+  public In(_i: number): Type {
+    return nonFunctionTypePanic('In', this)
+  }
+
+  public NumOut(): number {
+    return nonFunctionTypePanic('NumOut', this)
+  }
+
+  public Out(_i: number): Type {
+    return nonFunctionTypePanic('Out', this)
+  }
+
+  public IsVariadic(): boolean {
+    return nonFunctionTypePanic('IsVariadic', this)
+  }
+
   public PkgPath(): string {
     if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
       return ''
@@ -2487,8 +3575,14 @@ class InterfaceType implements Type {
     throw new Error('reflect: Key of non-map type')
   }
 
-  public Implements(_u: Type | null): boolean {
-    return false
+  public Implements(u: Type | null): boolean {
+    if (!u) {
+      return false
+    }
+    if (u.Kind() !== Interface) {
+      throw new Error('reflect: non-interface type passed to Type.Implements')
+    }
+    return typeImplementsInterface(this, u)
   }
 
   public AssignableTo(u: Type | null): boolean {
@@ -2536,6 +3630,10 @@ class InterfaceType implements Type {
   public registeredName(): string | undefined {
     return this._registeredName
   }
+
+  public methodSignatures(): $.MethodSignature[] {
+    return this._methods
+  }
 }
 
 function getTypeOf(value: ReflectValue): Type {
@@ -2583,24 +3681,20 @@ function getTypeOf(value: ReflectValue): Type {
           typeInfo.params &&
           typeInfo.results
         ) {
+          if (funcWithMeta.__goTypeName && !typeInfo.name) {
+            return functionTypeFromInfo({
+              ...typeInfo,
+              name: funcWithMeta.__goTypeName,
+            })
+          }
           return functionTypeFromInfo(typeInfo)
         }
       }
 
       // Then check for __goTypeName which indicates a typed function
       if (funcWithMeta.__goTypeName) {
-        // This is a typed Go function - try to reconstruct the signature
         const typeName = funcWithMeta.__goTypeName
-
-        // For known Go function types, construct proper signatures
-        if (typeName === 'Greeter') {
-          return new FunctionType('func(string) string')
-        } else if (typeName === 'Adder') {
-          return new FunctionType('func(int, int) int')
-        }
-
-        // Generic fallback for typed functions
-        return new FunctionType(`func`) // Could be enhanced with parameter parsing
+        return new FunctionType({ name: typeName })
       }
 
       // For untyped functions, try to parse the signature
@@ -2734,6 +3828,19 @@ function getTypeOf(value: ReflectValue): Type {
       }
 
       // Check if it has a constructor with __typeInfo for proper struct names
+      if (
+        value &&
+        typeof value === 'object' &&
+        value.constructor &&
+        '__reflectType' in value.constructor
+      ) {
+        const reflectType = (value.constructor as { __reflectType?: Type })
+          .__reflectType
+        if (reflectType) {
+          return reflectType
+        }
+      }
+
       if (
         value &&
         typeof value === 'object' &&
@@ -2741,34 +3848,19 @@ function getTypeOf(value: ReflectValue): Type {
         '__typeInfo' in value.constructor
       ) {
         const typeInfo = (
-          value.constructor as { __typeInfo?: { name?: string } }
+          value.constructor as { __typeInfo?: $.StructTypeInfo }
         ).__typeInfo
-        if (typeInfo && typeInfo.name) {
-          const typeName =
-            typeInfo.name.includes('.') ?
-              typeInfo.name
-            : `main.${typeInfo.name}`
-          const regTypeInfo = builtinGetTypeByName(typeName)
-          let fields: Array<{ name: string; type: Type; tag?: string }> = []
-          if (regTypeInfo && isStructTypeInfo(regTypeInfo)) {
-            fields = Object.entries(regTypeInfo.fields || {}).map(
-              ([name, fieldInfo]) => {
-                // Check if fieldInfo is a StructFieldInfo with type and tag
-                if (isStructFieldInfo(fieldInfo)) {
-                  return {
-                    name: fieldInfo.name ?? name,
-                    type: StructType.createTypeFromFieldInfo(fieldInfo.type),
-                    tag: fieldInfo.tag,
-                  }
-                }
-                // Otherwise it's just the type info directly (backwards compatible)
-                return {
-                  name,
-                  type: StructType.createTypeFromFieldInfo(fieldInfo),
-                }
-              },
-            )
+        if (typeInfo && isStructTypeInfo(typeInfo)) {
+          const name = typeInfo.name ?? ''
+          if (name === '') {
+            return new StructType('', structFieldsFromTypeInfo(typeInfo))
           }
+          const typeName = name.includes('.') ? name : `main.${name}`
+          const regTypeInfo = builtinGetTypeByName(typeName)
+          const fields =
+            regTypeInfo && isStructTypeInfo(regTypeInfo) ?
+              structFieldsFromTypeInfo(regTypeInfo)
+            : structFieldsFromTypeInfo(typeInfo)
           return new StructType(typeName, fields)
         }
       }
@@ -2832,20 +3924,168 @@ export function ChanOf(dir: ChanDir, t: Type): Type {
   return internType(new ChannelType(t, dir))
 }
 
+export function StructOf(fields: $.Slice<StructField>): Type {
+  const inputFields = $.asArray(fields)
+  const descriptors: StructFieldDescriptor[] = []
+  const names = new Set<string>()
+  let pkgPath = ''
+  let offset = 0
+  for (const [idx, field] of inputFields.entries()) {
+    validateStructOfField(field, idx)
+    if (field.PkgPath !== '') {
+      if (pkgPath === '') {
+        pkgPath = field.PkgPath
+      } else if (pkgPath !== field.PkgPath) {
+        throw new Error(
+          `reflect.Struct: fields with different PkgPath ${pkgPath} and ${field.PkgPath}`,
+        )
+      }
+    }
+    if (names.has(field.Name) && field.Name !== '_') {
+      throw new Error(`reflect.StructOf: duplicate field ${field.Name}`)
+    }
+    names.add(field.Name)
+
+    const fieldOffset = alignOffset(offset, typeAlignment(field.Type))
+    const tag = field.Tag?.toString()
+    const descriptor: StructFieldDescriptor = {
+      name: field.Name,
+      key: field.Name === '_' ? `_${idx}` : field.Name,
+      type: field.Type,
+      ...(tag ? { tag } : {}),
+      pkgPath: field.PkgPath,
+      anonymous: field.Anonymous,
+      index: [idx],
+      offset: fieldOffset,
+      exported: field.IsExported(),
+    }
+    descriptors.push(descriptor)
+    offset = fieldOffset + field.Type.Size()
+  }
+  return internType(
+    new StructType('', descriptors, '', structTypeString(descriptors)),
+  )
+}
+
+function validateStructOfField(field: StructField, idx: number): void {
+  if (field.Name === '') {
+    throw new Error(`reflect.StructOf: field ${idx} has no name`)
+  }
+  if (!isValidStructFieldName(field.Name)) {
+    throw new Error(`reflect.StructOf: field ${idx} has invalid name`)
+  }
+  if (!field.Type) {
+    throw new Error(`reflect.StructOf: field ${idx} has no type`)
+  }
+  if (field.Anonymous && field.PkgPath !== '') {
+    throw new Error(
+      `reflect.StructOf: field "${field.Name}" is anonymous but has PkgPath set`,
+    )
+  }
+  if (field.IsExported() && isUnexportedStructFieldName(field.Name)) {
+    throw new Error(
+      `reflect.StructOf: field "${field.Name}" is unexported but missing PkgPath`,
+    )
+  }
+  validateAnonymousStructOfField(field)
+}
+
+function isValidStructFieldName(name: string): boolean {
+  return /^[\p{L}_][\p{L}\p{N}_]*$/u.test(name)
+}
+
+function isUnexportedStructFieldName(name: string): boolean {
+  const first = name.charCodeAt(0)
+  return name[0] === '_' || (first >= 97 && first <= 122)
+}
+
+function validateAnonymousStructOfField(field: StructField): void {
+  if (!field.Anonymous) {
+    return
+  }
+  const typ = field.Type
+  if (typ.Kind() === Ptr) {
+    const elem = typ.Elem()
+    if (elem.Kind() === Ptr || elem.Kind() === Interface) {
+      throw new Error(
+        `reflect.StructOf: illegal embedded field type ${typ.String()}`,
+      )
+    }
+    if (embeddedMethodCount(typ) > 0) {
+      throw new Error('reflect: embedded type with methods not implemented')
+    }
+    return
+  }
+  if (embeddedMethodCount(typ) > 0) {
+    throw new Error('reflect: embedded type with methods not implemented')
+  }
+}
+
+function embeddedMethodCount(typ: Type): number {
+  if (typ.Kind() === Ptr) {
+    return Math.max(typ.NumMethod(), typ.Elem().NumMethod())
+  }
+  return typ.NumMethod()
+}
+
+function structTypeString(fields: StructFieldDescriptor[]): string {
+  if (fields.length === 0) {
+    return 'struct {}'
+  }
+  return `struct { ${fields.map(structFieldString).join('; ')} }`
+}
+
+function structFieldString(field: StructFieldDescriptor): string {
+  const tag = field.tag ? ` ${JSON.stringify(field.tag)}` : ''
+  const prefix = field.anonymous ? '' : `${field.name} `
+  return `${prefix}${field.type.String()}${tag}`
+}
+
+export function FuncOf(
+  inTypes: $.Slice<Type | null>,
+  outTypes: $.Slice<Type | null>,
+  variadic: boolean,
+): Type {
+  const params = $.asArray(inTypes).map(funcOfType)
+  const results = $.asArray(outTypes).map(funcOfType)
+  if (
+    variadic &&
+    (params.length === 0 || params[params.length - 1].Kind() !== Slice)
+  ) {
+    throw new Error('reflect.FuncOf: last arg of variadic func must be slice')
+  }
+  if (params.length + results.length > 128) {
+    throw new Error('reflect.FuncOf: too many arguments')
+  }
+  return internType(new FunctionType({ params, results, variadic }))
+}
+
+function funcOfType(typ: Type | null | undefined): Type {
+  if (!typ) {
+    throw new Error('reflect.FuncOf: nil Type')
+  }
+  return typ
+}
+
 export function TypeFor(typeArgs?: $.GenericTypeArgs): Type {
   const descriptor = typeArgs?.T
+  const methodSignatures = genericMethodSignatures(descriptor)
   if (descriptor?.type) {
-    return internType(typeFromTypeInfo(descriptor.type))
-  }
-  if (descriptor?.methods) {
-    const methods = Object.keys(descriptor.methods)
-    if (methods.length !== 0) {
-      return internType(
-        new InterfaceType(
-          `interface { ${methods.map((method) => method + '()').join('; ')} }`,
-        ),
-      )
-    }
+    return internType(
+      typeWithMethodSignatures(
+        typeFromTypeInfo(descriptor.type),
+        methodSignatures,
+      ),
+    )
+  }
+  if (methodSignatures.length !== 0) {
+    return internType(
+      new InterfaceType(
+        interfaceTypeString(methodSignatures),
+        undefined,
+        methodSignatures,
+      ),
+    )
   }
   if (descriptor?.zero) {
     return internType(getTypeOf(descriptor.zero()))
@@ -2853,113 +4093,475 @@ export function TypeFor(typeArgs?: $.GenericTypeArgs): Type {
   return internType(new InterfaceType('interface{}'))
 }
 
+function genericMethodSignatures(
+  descriptor: $.GenericTypeDescriptor | undefined,
+): $.MethodSignature[] {
+  if (!descriptor) {
+    return []
+  }
+  if (descriptor.methodSignatures && descriptor.methodSignatures.length !== 0) {
+    return descriptor.methodSignatures
+  }
+  if (!descriptor.methods) {
+    return []
+  }
+  return Object.keys(descriptor.methods).map((method) => ({
+    name: method,
+    args: [],
+    returns: [],
+  }))
+}
+
+function typeWithMethodSignatures(
+  typ: Type,
+  methods: $.MethodSignature[],
+): Type {
+  if (methods.length === 0) {
+    return typ
+  }
+  if (typ instanceof BasicType) {
+    typ.mergeMethodSignatures(methods)
+    return typ
+  }
+  if (typ instanceof PointerType) {
+    typ.mergeMethodSignatures(methods)
+    return typ
+  }
+  if (typ instanceof FunctionType) {
+    typ.mergeMethodSignatures(methods)
+    return typ
+  }
+  return typ
+}
+
 function typeFromTypeInfo(info: $.TypeInfo | string): Type {
+  return typeFromTypeInfoWithSeen(info, new Set())
+}
+
+function typeFromTypeInfoWithSeen(
+  info: $.TypeInfo | string,
+  seen: Set<string>,
+): Type {
   if (typeof info === 'string') {
     const registered = builtinGetTypeByName(info)
     if (registered) {
-      return internType(typeFromTypeInfo(registered))
+      const typ = typeFromTypeInfoWithSeen(registered, seen)
+      return internType(typ)
     }
-    return internType(StructType.createTypeFromFieldInfo(info))
+    return internType(StructType.createTypeFromFieldInfo(info, seen))
   }
+  const recursiveName = recursiveTypeInfoName(info)
+  if (recursiveName !== '') {
+    const constructing = constructingRegisteredTypes.get(recursiveName)
+    if (constructing) {
+      return constructing
+    }
+    if (seen.has(recursiveName)) {
+      return internType(shallowTypeFromRegisteredInfo(recursiveName, info))
+    }
+    if (info.kind === $.TypeKind.Struct) {
+      const typ = new StructType(recursiveName, [])
+      constructingRegisteredTypes.set(recursiveName, typ)
+      seen.add(recursiveName)
+      try {
+        typ.replaceDescriptors(structFieldsFromTypeInfo(info, seen))
+        return internType(typ)
+      } finally {
+        seen.delete(recursiveName)
+        constructingRegisteredTypes.delete(recursiveName)
+      }
+    }
+    seen.add(recursiveName)
+    const typ = typeFromStructuredTypeInfoWithSeen(info, seen)
+    seen.delete(recursiveName)
+    return internType(typ)
+  }
+  return internType(typeFromStructuredTypeInfoWithSeen(info, seen))
+}
+
+function recursiveTypeInfoName(info: $.TypeInfo): string {
+  if (info.kind === $.TypeKind.Basic) {
+    return info.typeName ?? ''
+  }
+  return info.name ?? ''
+}
+
+function typeFromStructuredTypeInfoWithSeen(
+  info: $.TypeInfo,
+  seen: Set<string>,
+): Type {
   switch (info.kind) {
     case $.TypeKind.Array:
-      return internType(
-        new ArrayType(
-          typeFromTypeInfo(
-            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
-          ),
-          info.length,
+      return new ArrayType(
+        typeFromTypeInfoWithSeen(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          seen,
         ),
+        info.length,
       )
     case $.TypeKind.Basic:
-      return internType(StructType.createTypeFromFieldInfo(info))
+      return StructType.createTypeFromFieldInfo(info, seen)
     case $.TypeKind.Channel:
-      return internType(
-        new ChannelType(
-          typeFromTypeInfo(
-            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
-          ),
-          chanDirFromTypeInfo(info.direction),
+      return new ChannelType(
+        typeFromTypeInfoWithSeen(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          seen,
         ),
+        chanDirFromTypeInfo(info.direction),
       )
     case $.TypeKind.Function:
-      return internType(functionTypeFromInfo(info))
+      return functionTypeFromInfo(info, seen)
     case $.TypeKind.Interface:
-      return internType(interfaceTypeFromInfo(info))
+      return interfaceTypeFromInfo(info, seen)
     case $.TypeKind.Map:
-      return internType(
-        new MapType(
-          typeFromTypeInfo(
-            info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
-          ),
-          typeFromTypeInfo(
-            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
-          ),
+      return new MapType(
+        typeFromTypeInfoWithSeen(
+          info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          seen,
+        ),
+        typeFromTypeInfoWithSeen(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          seen,
         ),
       )
     case $.TypeKind.Slice:
-      return internType(
-        new SliceType(
-          typeFromTypeInfo(
-            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
-          ),
+      return new SliceType(
+        typeFromTypeInfoWithSeen(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          seen,
         ),
       )
     case $.TypeKind.Struct:
-      return internType(StructType.createTypeFromFieldInfo(info))
+      return StructType.createTypeFromFieldInfo(info, seen)
     case $.TypeKind.Pointer:
-      return internType(
-        new PointerType(
-          typeFromTypeInfo(
-            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
-          ),
+      return new PointerType(
+        typeFromTypeInfoWithSeen(
+          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          seen,
         ),
       )
     default:
-      return internType(StructType.createTypeFromFieldInfo(info))
+      return StructType.createTypeFromFieldInfo(info, seen)
   }
 }
 
-function functionTypeFromInfo(info: $.FunctionTypeInfo): Type {
-  if (info.name) {
-    return new FunctionType(info.name)
+function shallowTypeFromRegisteredInfo(name: string, info: $.TypeInfo): Type {
+  switch (info.kind) {
+    case $.TypeKind.Interface:
+      return new InterfaceType(name, name, info.methods ?? [])
+    case $.TypeKind.Struct:
+      return new StructType(name, [])
+    case $.TypeKind.Function:
+      return new FunctionType({ name })
+    case $.TypeKind.Basic:
+      return StructType.createTypeFromFieldInfo({
+        kind: $.TypeKind.Basic,
+        name: info.name ?? 'unknown',
+        typeName: info.typeName ?? name,
+      })
+    default:
+      return StructType.createTypeFromFieldInfo(name)
   }
-  const params = info.params ?? []
-  const paramTypes = params.map((param, index) => {
-    const typeName = functionSignatureTypeName(param)
-    if (!info.isVariadic || index !== params.length - 1) {
-      return typeName
-    }
-    if (typeName.startsWith('[]')) {
-      return '...' + typeName.slice(2)
-    }
-    return '...' + typeName
+}
+
+function functionTypeFromInfo(
+  info: $.FunctionTypeInfo,
+  seen = new Set<string>(),
+): Type {
+  const params = (info.params ?? []).map((param) =>
+    typeFromTypeInfoWithSeen(param, seen),
+  )
+  const results = (info.results ?? []).map((result) =>
+    typeFromTypeInfoWithSeen(result, seen),
+  )
+  return new FunctionType({
+    name: info.name,
+    params,
+    results,
+    variadic: info.isVariadic ?? false,
   })
-  const resultTypes = (info.results ?? []).map(functionSignatureTypeName)
-  let signature = `func(${paramTypes.join(', ')})`
-  if (resultTypes.length === 1) {
-    signature += ` ${resultTypes[0]}`
+}
+
+function functionTypeInfoFromType(typ: Type): $.FunctionTypeInfo {
+  const params: (string | $.TypeInfo)[] = []
+  for (let i = 0; i < typ.NumIn(); i++) {
+    params.push(typeInfoFromReflectType(typ.In(i)))
+  }
+  const results: (string | $.TypeInfo)[] = []
+  for (let i = 0; i < typ.NumOut(); i++) {
+    results.push(typeInfoFromReflectType(typ.Out(i)))
   }
-  if (resultTypes.length > 1) {
-    signature += ` (${resultTypes.join(', ')})`
+  const info: $.FunctionTypeInfo = {
+    kind: $.TypeKind.Function,
+    params,
+    results,
+  }
+  if (typ.Name() !== '') {
+    info.name = typ.String()
+  }
+  if (typ.IsVariadic()) {
+    info.isVariadic = true
+  }
+  return info
+}
+
+export function typeInfoFromReflectType(typ: Type): string | $.TypeInfo {
+  if (typ.PkgPath() !== '' && typ.Name() !== '') {
+    return typ.String()
+  }
+  switch (typ.Kind()) {
+    case Bool:
+    case Int:
+    case Int8:
+    case Int16:
+    case Int32:
+    case Int64:
+    case Uint:
+    case Uint8:
+    case Uint16:
+    case Uint32:
+    case Uint64:
+    case Uintptr:
+    case Float32:
+    case Float64:
+    case Complex64:
+    case Complex128:
+    case String:
+    case UnsafePointer:
+      return { kind: $.TypeKind.Basic, name: typ.String() }
+    case Interface:
+      return {
+        kind: $.TypeKind.Interface,
+        methods: typeMethods(typ).map((method) => ({
+          name: method.name,
+          args: method.args,
+          returns: method.returns,
+        })),
+      }
+    case Slice:
+      return {
+        kind: $.TypeKind.Slice,
+        elemType: typeInfoFromReflectType(typ.Elem()),
+      }
+    case Array:
+      return {
+        kind: $.TypeKind.Array,
+        elemType: typeInfoFromReflectType(typ.Elem()),
+        length: typ.Len(),
+      }
+    case Ptr:
+      return {
+        kind: $.TypeKind.Pointer,
+        elemType: typeInfoFromReflectType(typ.Elem()),
+      }
+    case Map:
+      return {
+        kind: $.TypeKind.Map,
+        keyType: typeInfoFromReflectType(typ.Key()),
+        elemType: typeInfoFromReflectType(typ.Elem()),
+      }
+    case Chan:
+      return {
+        kind: $.TypeKind.Channel,
+        elemType: typeInfoFromReflectType(typ.Elem()),
+        direction: channelDirectionFromString(typ.String()),
+      }
+    case Func:
+      return functionTypeInfoFromType(typ)
+    case Struct: {
+      const fields =
+        typ instanceof StructType ?
+          typ.descriptors()
+        : globalThis.Array.from({ length: typ.NumField() }, (_unused, idx) => {
+            const field = typ.Field(idx)
+            return {
+              name: field.Name,
+              key: structFieldStorageKey(typ, idx),
+              type: field.Type,
+              tag: field.Tag?.toString(),
+              pkgPath: field.PkgPath,
+              anonymous: field.Anonymous,
+              index: [...field.Index],
+              offset: field.Offset,
+              exported: field.IsExported(),
+            }
+          })
+      return {
+        kind: $.TypeKind.Struct,
+        name: typ.Name() === '' ? '' : typ.String(),
+        methods: [],
+        fields: fields.map((field) => ({
+          name: field.name,
+          key: field.key,
+          type: typeInfoFromReflectType(field.type),
+          ...(field.tag ? { tag: field.tag } : {}),
+          ...(field.pkgPath ? { pkgPath: field.pkgPath } : {}),
+          ...(field.anonymous ? { anonymous: true } : {}),
+          index: [...field.index],
+          offset: field.offset,
+          exported: field.exported,
+        })),
+      }
+    }
+    default:
+      return typ.String()
   }
-  return new FunctionType(signature)
 }
 
-function functionSignatureTypeName(info: $.TypeInfo | string): string {
-  return typeFromTypeInfo(info).String()
+function channelDirectionFromString(
+  typeName: string,
+): 'send' | 'receive' | 'both' {
+  if (typeName.startsWith('<-chan ')) {
+    return 'receive'
+  }
+  if (typeName.startsWith('chan<- ')) {
+    return 'send'
+  }
+  return 'both'
 }
 
-function interfaceTypeFromInfo(info: $.InterfaceTypeInfo): Type {
-  if (info.methods.length === 0) {
-    return new InterfaceType('interface{}', info.name)
+function interfaceTypeFromInfo(
+  info: $.InterfaceTypeInfo,
+  seen = new Set<string>(),
+): Type {
+  const methods = info.methods ?? []
+  if (methods.length === 0) {
+    return new InterfaceType('interface{}', info.name, methods)
   }
   return new InterfaceType(
-    `interface { ${info.methods.map((method) => method.name + '()').join('; ')} }`,
+    interfaceTypeString(methods, seen),
     info.name,
+    methods,
   )
 }
 
+function interfaceTypeString(
+  methods: $.MethodSignature[],
+  seen = new Set<string>(),
+): string {
+  return `interface { ${methods
+    .map((method) => interfaceMethodString(method, seen))
+    .join('; ')} }`
+}
+
+function interfaceMethodString(
+  method: $.MethodSignature,
+  seen: Set<string>,
+): string {
+  const args = method.args.map((arg) => methodArgString(arg, seen)).join(', ')
+  const returns = method.returns.map((arg) => methodArgString(arg, seen))
+  if (returns.length === 0) {
+    return `${method.name}(${args})`
+  }
+  if (returns.length === 1) {
+    return `${method.name}(${args}) ${returns[0]}`
+  }
+  return `${method.name}(${args}) (${returns.join(', ')})`
+}
+
+function structTypeInfoString(
+  info: $.StructTypeInfo,
+  seen: Set<string>,
+): string {
+  if (info.name) {
+    return info.name
+  }
+  const fields = info.fields ?? []
+  if (fields.length === 0) {
+    return 'struct {}'
+  }
+  return `struct { ${fields
+    .map((field) => structFieldInfoString(field, seen))
+    .join('; ')} }`
+}
+
+function structFieldInfoString(
+  field: $.StructFieldInfo,
+  seen: Set<string>,
+): string {
+  const tag = field.tag ? ` ${JSON.stringify(field.tag)}` : ''
+  const prefix = field.anonymous ? '' : `${field.name} `
+  return `${prefix}${typeInfoString(field.type, seen)}${tag}`
+}
+
+function methodArgString(arg: $.MethodArg, seen: Set<string>): string {
+  return typeInfoString(arg.type, seen)
+}
+
+function typeInfoString(info: $.TypeInfo | string, seen: Set<string>): string {
+  if (typeof info === 'string') {
+    return info
+  }
+  switch (info.kind) {
+    case $.TypeKind.Basic:
+      return info.typeName ?? info.name ?? 'unknown'
+    case $.TypeKind.Interface: {
+      const name = info.name ?? ''
+      if (name !== '' && seen.has(name)) {
+        return name
+      }
+      if (info.methods.length === 0) {
+        return 'interface{}'
+      }
+      if (name !== '') {
+        seen.add(name)
+      }
+      const text = interfaceTypeString(info.methods, seen)
+      if (name !== '') {
+        seen.delete(name)
+      }
+      return text
+    }
+    case $.TypeKind.Struct:
+      return structTypeInfoString(info, seen)
+    case $.TypeKind.Pointer:
+      return `*${typeInfoString(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    case $.TypeKind.Slice:
+      return `[]${typeInfoString(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    case $.TypeKind.Array:
+      return `[${info.length}]${typeInfoString(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    case $.TypeKind.Map:
+      return `map[${typeInfoString(
+        info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}]${typeInfoString(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    case $.TypeKind.Function: {
+      const params = (info.params ?? [])
+        .map((param) => typeInfoString(param, seen))
+        .join(', ')
+      const results = (info.results ?? []).map((result) =>
+        typeInfoString(result, seen),
+      )
+      if (results.length === 0) {
+        return `func(${params})`
+      }
+      if (results.length === 1) {
+        return `func(${params}) ${results[0]}`
+      }
+      return `func(${params}) (${results.join(', ')})`
+    }
+    case $.TypeKind.Channel:
+      return `chan ${typeInfoString(
+        info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+        seen,
+      )}`
+    default:
+      return 'unknown'
+  }
+}
+
 function chanDirFromTypeInfo(direction?: 'send' | 'receive' | 'both'): ChanDir {
   switch (direction) {
     case 'send':
@@ -2977,38 +4579,16 @@ function chanDirFromTypeInfo(direction?: 'send' | 'receive' | 'both'): ChanDir {
  */
 export function getInterfaceTypeByName(name: string): Type {
   const typeInfo = builtinGetTypeByName(name)
-  if (typeInfo && typeInfo.kind === TypeKind.Interface) {
-    return new InterfaceType(name, name)
+  if (typeInfo && isInterfaceTypeInfo(typeInfo)) {
+    return new InterfaceType(name, name, typeInfo.methods ?? [])
   }
   return new InterfaceType('interface{}')
 }
 
 export function getInterfaceLiteralTypeByName(name: string): Type {
   const typeInfo = builtinGetTypeByName(name)
-  if (typeInfo && typeInfo.kind === TypeKind.Interface) {
-    const methods = (typeInfo as any).methods || []
-    if (methods.length === 0) {
-      return new InterfaceType('interface{}', name)
-    }
-    const methodSigs = methods
-      .map((m: any) => {
-        const args =
-          m.args
-            ?.map((a: any) => (typeof a === 'string' ? a : 'any'))
-            .join(', ') || ''
-        const returns = m.returns?.map((r: any) =>
-          typeof r === 'string' ? r : 'any',
-        )
-        let returnSig = ''
-        if (returns && returns.length === 1) {
-          returnSig = ` ${returns[0]}`
-        } else if (returns && returns.length > 1) {
-          returnSig = ` (${returns.join(', ')})`
-        }
-        return `${m.name}(${args})${returnSig}`
-      })
-      .join('; ')
-    return new InterfaceType(`interface { ${methodSigs} }`, name)
+  if (typeInfo && isInterfaceTypeInfo(typeInfo)) {
+    return interfaceTypeFromInfo(typeInfo)
   }
   return new InterfaceType('interface{}')
 }