goscript 0.1.0 → 0.1.2

package/gs/reflect/type.ts

@@ -1,4 +1,10 @@
-import { ReflectValue, StructField, StructTag, ValueError } from './types.js'
+import {
+  Method,
+  ReflectValue,
+  StructField,
+  StructTag,
+  ValueError,
+} from './types.js'
 export { StructField }
 import { MapIter } from './map.js'
 import {
@@ -173,6 +179,31 @@ export const String: Kind = 24
 export const Struct: Kind = 25
 export const UnsafePointer: Kind = 26
 
+const pointerAddressStride = 0x100000000
+const pointerAddresses = new WeakMap<object, number>()
+let nextPointerAddress = 1
+const canonicalTypes = new globalThis.Map<string, Type>()
+
+function pointerAddress(value: object): number {
+  let address = pointerAddresses.get(value)
+  if (address === undefined) {
+    address = nextPointerAddress * pointerAddressStride
+    nextPointerAddress++
+    pointerAddresses.set(value, address)
+  }
+  return address
+}
+
+function internType(t: Type): Type {
+  const key = `${t.Kind()}:${t.PkgPath()}:${t.Name()}:${t.String()}`
+  const existing = canonicalTypes.get(key)
+  if (existing) {
+    return existing
+  }
+  canonicalTypes.set(key, t)
+  return t
+}
+
 // Type is the representation of a Go type.
 export interface Type {
   // String returns a string representation of the type.
@@ -192,12 +223,18 @@ export interface Type {
   NumField(): number
 
   // PkgPath returns the package path for named types, empty for unnamed types.
-  PkgPath?(): string
+  PkgPath(): string
 
   // Field returns a struct type's i'th field.
   // Panics if the type's Kind is not Struct or i is out of range.
   Field(i: number): StructField
 
+  // FieldByName returns the struct field with the given name.
+  FieldByName(name: string): [StructField, boolean]
+
+  // FieldByNameFunc returns the first struct field whose name satisfies match.
+  FieldByNameFunc(match: (name: string) => boolean): [StructField, boolean]
+
   // Key returns a map type's key type.
   // Panics if the type's Kind is not Map.
   Key(): Type
@@ -208,6 +245,9 @@ export interface Type {
   // Implements reports whether the type implements the interface type u.
   Implements(u: Type | null): boolean
 
+  // AssignableTo reports whether a value of this type is assignable to u.
+  AssignableTo(u: Type | null): boolean
+
   // common returns the common type implementation.
   common?(): rtype
 
@@ -226,9 +266,19 @@ export interface Type {
   // NumMethod returns the number of methods in the type's method set
   NumMethod(): number
 
+  // MethodByName returns the method with that name in the type's method set.
+  MethodByName(name: string): [Method, boolean]
+
+  // Len returns an array type's length.
+  // Panics if the type's Kind is not Array.
+  Len(): number
+
   // Bits returns the size of the type in bits
   // Panics if the type's Kind is not a sized type.
   Bits(): number
+
+  // Comparable reports whether values of this type are comparable.
+  Comparable(): boolean
 }
 
 // InvalidTypeInstance is a singleton type for invalid/zero reflect.Value
@@ -236,12 +286,18 @@ class InvalidTypeClass implements Type {
   Kind(): Kind {
     return Invalid
   }
+  Comparable(): boolean {
+    return false
+  }
   String(): string {
     return '<invalid reflect.Value>'
   }
   Name(): string {
     return ''
   }
+  PkgPath(): string {
+    return ''
+  }
   Size(): number {
     return 0
   }
@@ -257,9 +313,18 @@ class InvalidTypeClass implements Type {
   Field(_i: number): StructField {
     throw new Error('reflect: Field of invalid type')
   }
+  FieldByName(_name: string): [StructField, boolean] {
+    return [new StructField(), false]
+  }
+  FieldByNameFunc(_match: (name: string) => boolean): [StructField, boolean] {
+    return [new StructField(), false]
+  }
   Implements(_u: Type | null): boolean {
     return false
   }
+  AssignableTo(_u: Type | null): boolean {
+    return false
+  }
   OverflowInt(_x: number): boolean {
     throw new Error('reflect: OverflowInt of invalid type')
   }
@@ -272,6 +337,12 @@ class InvalidTypeClass implements Type {
   NumMethod(): number {
     return 0
   }
+  MethodByName(_name: string): [Method, boolean] {
+    return [zeroMethod(), false]
+  }
+  Len(): number {
+    throw new Error('reflect: Len of invalid type')
+  }
   Bits(): number {
     throw new Error('reflect: Bits of invalid type')
   }
@@ -458,6 +529,35 @@ export class Value {
     )
   }
 
+  public Slice(i: number, j: number): Value {
+    const length = this.Len()
+    if (i < 0 || j < i || j > length) {
+      throw new Error(
+        `reflect.Value.Slice: slice index out of bounds [${i}:${j}] with length ${length}`,
+      )
+    }
+    if (
+      this._value &&
+      typeof this._value === 'object' &&
+      '__meta__' in this._value
+    ) {
+      return new Value(
+        $.goSlice(this._value as $.Slice<unknown>, i, j),
+        this._type,
+      )
+    }
+    if (globalThis.Array.isArray(this._value)) {
+      return new Value(this._value.slice(i, j), this._type)
+    }
+    if (this._value instanceof Uint8Array) {
+      return new Value(this._value.slice(i, j), this._type)
+    }
+    if (typeof this._value === 'string') {
+      return new Value(this._value.slice(i, j), this._type)
+    }
+    throw new ValueError({ Kind: this.Kind(), Method: 'Slice' })
+  }
+
   public Bytes(): Uint8Array {
     if (this._value instanceof Uint8Array) {
       return this._value
@@ -503,11 +603,76 @@ export class Value {
     return new Value(fieldVal, field.Type, undefined, parentObj, field.Name)
   }
 
+  public FieldByIndex(index: $.Slice<number>): Value {
+    let current: Value = this
+    for (const fieldIndex of $.asArray(index)) {
+      current = current.Field(fieldIndex)
+    }
+    return current
+  }
+
+  public FieldByName(name: string): Value {
+    const [field, ok] = this.Type().FieldByName(name)
+    if (!ok) {
+      return new Value(null, invalidTypeInstance)
+    }
+    return this.FieldByIndex(field.Index)
+  }
+
   // Additional methods needed by various parts of the codebase
   public UnsafePointer(): unknown {
     return this._value
   }
 
+  public Pointer(): number {
+    const kind = this.Kind()
+    if (
+      kind !== Chan &&
+      kind !== Func &&
+      kind !== Map &&
+      kind !== Ptr &&
+      kind !== Slice &&
+      kind !== UnsafePointer
+    ) {
+      throw new ValueError({ Kind: kind, Method: 'Pointer' })
+    }
+    if (this._value === null || this._value === undefined) {
+      return 0
+    }
+    if ($.isVarRef(this._value)) {
+      const address = this._value.__goAddress?.()
+      if (address !== undefined) {
+        return address
+      }
+      return pointerAddress(this._value)
+    }
+    if (kind === Slice) {
+      const slice = this._value as $.Slice<unknown> | Uint8Array
+      try {
+        if ($.len(slice) === 0) {
+          return 0
+        }
+        return $.indexAddress(slice, 0)
+      } catch {
+        return 0
+      }
+    }
+    if (typeof this._value === 'object' || typeof this._value === 'function') {
+      return pointerAddress(this._value)
+    }
+    return 0
+  }
+
+  public UnsafeAddr(): number | { value: Value } {
+    if (!this.CanAddr()) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'UnsafeAddr' })
+    }
+    if (this._parentStruct && this._fieldName) {
+      return { value: this }
+    }
+    return this.Pointer()
+  }
+
   public pointer(): unknown {
     return this._value
   }
@@ -536,7 +701,10 @@ export class Value {
       throw new Error('reflect: call of reflect.Value.Addr on invalid Value')
     }
     const ptrType = PointerTo(this.Type())
-    return new Value(this, ptrType) // Simplified
+    if (this._parentStruct && this._fieldName) {
+      return new Value($.fieldRef(this._parentStruct, this._fieldName), ptrType)
+    }
+    return new Value($.varRef(this._value), ptrType)
   }
 
   public CanSet(): boolean {
@@ -584,6 +752,40 @@ export class Value {
     return this._value
   }
 
+  public MethodByName(name: string): Value {
+    if (!this.IsValid()) {
+      return new Value()
+    }
+    const receiver = $.isVarRef(this._value) ? this._value.value : this._value
+    if (
+      receiver === null ||
+      receiver === undefined ||
+      (typeof receiver !== 'object' && typeof receiver !== 'function')
+    ) {
+      return new Value()
+    }
+    const method = (receiver as Record<string, unknown>)[name]
+    if (typeof method !== 'function') {
+      return new Value()
+    }
+    return new Value(method.bind(receiver), new FunctionType('func'))
+  }
+
+  public Call(inArgs: $.Slice<Value>): $.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 $.arrayToSlice([ValueOf(result)])
+  }
+
   public IsZero(): boolean {
     const zeroVal = Zero(this.Type()).value
     return DeepEqual(this._value, zeroVal)
@@ -598,18 +800,64 @@ export class Value {
   }
 
   public MapRange(): MapIter<unknown, unknown> | null {
-    // Placeholder for map iteration
-    return null
+    if (this.Kind() !== Map) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'MapRange' })
+    }
+    if (this._value === null || this._value === undefined) {
+      return new MapIter(new globalThis.Map())
+    }
+    if (!(this._value instanceof globalThis.Map)) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'MapRange' })
+    }
+    return new MapIter(this._value)
+  }
+
+  public MapIndex(key: Value): Value {
+    if (this.Kind() !== Map) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'MapIndex' })
+    }
+    if (!(this._value instanceof globalThis.Map)) {
+      return new Value(null, new BasicType(Invalid, 'invalid'))
+    }
+    const rawKey = key.Interface()
+    if (!this._value.has(rawKey)) {
+      return new Value(null, new BasicType(Invalid, 'invalid'))
+    }
+    return new Value(
+      this._value.get(rawKey) as ReflectValue,
+      this.Type().Elem(),
+    )
   }
 
-  public MapIndex(_key: Value): Value {
-    // Placeholder for map access
-    return new Value(null, new BasicType(Invalid, 'invalid'))
+  public MapKeys(): $.Slice<Value> {
+    if (this.Kind() !== Map) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'MapKeys' })
+    }
+    if (this._value === null || this._value === undefined) {
+      return $.makeSlice<Value>(0)
+    }
+    if (!(this._value instanceof globalThis.Map)) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'MapKeys' })
+    }
+    const keyType = this.Type().Key()
+    const keys: Value[] = []
+    for (const key of this._value.keys()) {
+      keys.push(new Value(key as ReflectValue, keyType))
+    }
+    return $.arrayToSlice(keys)
   }
 
-  public Complex(): number | { real: number; imag: number } | null {
-    // Placeholder for complex number support
-    return this._value as number | { real: number; imag: number } | null
+  public Complex(): number | $.Complex | null {
+    const k = this.Kind()
+    if (k !== Complex64 && k !== Complex128) {
+      throw new Error(
+        'reflect: call of reflect.Value.Complex on ' +
+          Kind_String(k) +
+          ' Value',
+      )
+    }
+    const value = this._parentVarRef ? this._parentVarRef.value : this._value
+    return value as number | $.Complex | null
   }
 
   // Send sends a value to a channel
@@ -755,6 +1003,28 @@ export class Value {
     }
   }
 
+  // SetComplex sets v's underlying value to x
+  public SetComplex(x: number | $.Complex): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetComplex on unaddressable value',
+      )
+    }
+    const k = this.Kind()
+    if (k !== Complex64 && k !== Complex128) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetComplex on ' + k + ' Value',
+      )
+    }
+    this._value = x
+    if (this._parentVarRef) {
+      this._parentVarRef.value = x
+    }
+    if (this._parentStruct && this._fieldName) {
+      this._parentStruct[this._fieldName] = x
+    }
+  }
+
   // SetBytes sets v's underlying value to x
   public SetBytes(x: $.Slice<number>): void {
     if (!this.CanSet()) {
@@ -940,16 +1210,21 @@ export class BasicType implements Type {
     private _kind: Kind,
     private _name: string,
     private _size: number = 8,
+    private _typeName: string = '',
   ) {}
 
   public String(): string {
-    return this._name
+    return this._typeName || this._name
   }
 
   public Kind(): Kind {
     return this._kind
   }
 
+  public Comparable(): boolean {
+    return this._kind !== Func && this._kind !== Map && this._kind !== Slice
+  }
+
   public Size(): number {
     return this._size
   }
@@ -962,11 +1237,24 @@ export class BasicType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
+    if (this._typeName) {
+      const dotIndex = this._typeName.lastIndexOf('.')
+      if (dotIndex > 0) {
+        return this._typeName.substring(0, dotIndex)
+      }
+    }
     return ''
   }
 
   public Name(): string {
+    if (this._typeName) {
+      const dotIndex = this._typeName.lastIndexOf('.')
+      if (dotIndex >= 0) {
+        return this._typeName.substring(dotIndex + 1)
+      }
+      return this._typeName
+    }
     // Basic types have names like 'int', 'string', etc.
     return this._name
   }
@@ -975,6 +1263,16 @@ export class BasicType implements Type {
     throw new Error(`reflect: Field of non-struct type ${this._name}`)
   }
 
+  public FieldByName(name: string): [StructField, boolean] {
+    return typeFieldByName(this, name)
+  }
+
+  public FieldByNameFunc(
+    match: (name: string) => boolean,
+  ): [StructField, boolean] {
+    return typeFieldByNameFunc(this, match)
+  }
+
   public Key(): Type {
     throw new Error(`reflect: Key of non-map type ${this._name}`)
   }
@@ -989,6 +1287,10 @@ export class BasicType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public common?(): rtype {
     return new rtype(this._kind)
   }
@@ -1055,6 +1357,17 @@ export class BasicType implements Type {
   public NumMethod(): number {
     return 0
   }
+  public MethodByName(_name: string): [Method, boolean] {
+    return [zeroMethod(), false]
+  }
+
+  public Len(): number {
+    throw new Error(
+      'reflect: call of reflect.Type.Len on ' +
+        Kind_String(this._kind) +
+        ' Type',
+    )
+  }
 
   public Bits(): number {
     const k = this._kind
@@ -1075,6 +1388,10 @@ export class BasicType implements Type {
       case Uint64:
       case Float64:
         return 64
+      case Complex64:
+        return 64
+      case Complex128:
+        return 128
       case Int:
       case Uint:
       case Uintptr:
@@ -1099,6 +1416,10 @@ class SliceType implements Type {
     return Slice
   }
 
+  public Comparable(): boolean {
+    return false
+  }
+
   public Size(): number {
     return 24 // slice header size
   }
@@ -1111,7 +1432,7 @@ class SliceType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1124,6 +1445,16 @@ class SliceType implements Type {
     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 Key(): Type {
     throw new Error('reflect: Key of non-map type')
   }
@@ -1138,6 +1469,10 @@ class SliceType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public OverflowInt(_x: number): boolean {
     throw new Error('reflect: call of reflect.Type.OverflowInt on slice Type')
   }
@@ -1153,6 +1488,13 @@ class SliceType implements Type {
   public NumMethod(): number {
     return 0
   }
+  public MethodByName(_name: string): [Method, boolean] {
+    return [zeroMethod(), false]
+  }
+
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on slice Type')
+  }
 
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on slice Type')
@@ -1174,6 +1516,10 @@ class ArrayType implements Type {
     return Array
   }
 
+  public Comparable(): boolean {
+    return this._elemType.Comparable()
+  }
+
   public Size(): number {
     return this._elemType.Size() * this._len
   }
@@ -1190,7 +1536,7 @@ class ArrayType implements Type {
     return this._len
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1203,6 +1549,16 @@ class ArrayType implements Type {
     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 Key(): Type {
     throw new Error('reflect: Key of non-map type')
   }
@@ -1217,6 +1573,10 @@ class ArrayType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public common?(): rtype {
     return new rtype(this.Kind())
   }
@@ -1236,6 +1596,9 @@ class ArrayType implements Type {
   public NumMethod(): number {
     return 0
   }
+  public MethodByName(_name: string): [Method, boolean] {
+    return [zeroMethod(), false]
+  }
 
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on array Type')
@@ -1254,6 +1617,10 @@ class PointerType implements Type {
     return Ptr
   }
 
+  public Comparable(): boolean {
+    return true
+  }
+
   public Size(): number {
     return 8 // pointer size
   }
@@ -1266,7 +1633,7 @@ class PointerType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1279,6 +1646,16 @@ class PointerType implements Type {
     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 Key(): Type {
     throw new Error('reflect: Key of non-map type')
   }
@@ -1295,6 +1672,10 @@ class PointerType implements Type {
     return typeImplementsInterface(elemTypeName, u)
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public common?(): rtype {
     return new rtype(this.Kind())
   }
@@ -1318,6 +1699,13 @@ class PointerType implements Type {
   public NumMethod(): number {
     return 0
   }
+  public MethodByName(name: string): [Method, boolean] {
+    return typeMethodByName(this._elemType, name)
+  }
+
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on pointer Type')
+  }
 
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on pointer Type')
@@ -1336,6 +1724,10 @@ class FunctionType implements Type {
     return Func
   }
 
+  public Comparable(): boolean {
+    return false
+  }
+
   public Size(): number {
     return 8 // function pointer size
   }
@@ -1348,7 +1740,7 @@ class FunctionType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1361,6 +1753,16 @@ class FunctionType implements Type {
     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 Key(): Type {
     throw new Error('reflect: Key of non-map type')
   }
@@ -1375,6 +1777,10 @@ class FunctionType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public common?(): rtype {
     return new rtype(this.Kind())
   }
@@ -1394,6 +1800,13 @@ class FunctionType implements Type {
   public NumMethod(): number {
     return 0
   }
+  public MethodByName(_name: string): [Method, boolean] {
+    return [zeroMethod(), false]
+  }
+
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on func Type')
+  }
 
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on func Type')
@@ -1415,6 +1828,10 @@ class MapType implements Type {
     return Map
   }
 
+  public Comparable(): boolean {
+    return false
+  }
+
   public Size(): number {
     return 8 // map header size
   }
@@ -1431,7 +1848,7 @@ class MapType implements Type {
     return this._keyType
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1444,6 +1861,16 @@ class MapType implements Type {
     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
@@ -1454,6 +1881,10 @@ class MapType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public common?(): rtype {
     return new rtype(this.Kind())
   }
@@ -1473,6 +1904,13 @@ class MapType implements Type {
   public NumMethod(): number {
     return 0
   }
+  public MethodByName(_name: string): [Method, boolean] {
+    return [zeroMethod(), false]
+  }
+
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on map Type')
+  }
 
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on map Type')
@@ -1537,6 +1975,74 @@ function typeImplementsInterface(
   return true
 }
 
+function typeFieldByName(t: Type, name: string): [StructField, boolean] {
+  return typeFieldByNameFunc(t, (fieldName) => fieldName === name)
+}
+
+function typeFieldByNameFunc(
+  t: Type,
+  match: (name: string) => boolean,
+): [StructField, boolean] {
+  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)
+    if (match(field.Name)) {
+      return [field, true]
+    }
+  }
+  return [new StructField(), false]
+}
+
+function zeroMethod(): Method {
+  return {
+    Name: '',
+    Type: new BasicType(Invalid, '<invalid>'),
+    Func: () => undefined,
+    Index: 0,
+  }
+}
+
+function methodFromSignature(
+  signature: $.MethodSignature,
+  index: number,
+): Method {
+  return {
+    Name: signature.name,
+    Type: new FunctionType('func'),
+    Func: () => undefined,
+    Index: index,
+  }
+}
+
+function typeMethods(t: Type): $.MethodSignature[] {
+  const typeInfo = builtinGetTypeByName(t.String())
+  if (!typeInfo) {
+    return []
+  }
+  if (isStructTypeInfo(typeInfo) || isInterfaceTypeInfo(typeInfo)) {
+    return typeInfo.methods || []
+  }
+  return []
+}
+
+function typeMethodByName(t: Type, name: string): [Method, boolean] {
+  const methods = typeMethods(t)
+  const index = methods.findIndex((method) => method.name === name)
+  if (index === -1) {
+    return [zeroMethod(), false]
+  }
+  return [methodFromSignature(methods[index], index), true]
+}
+
+function typeAssignableTo(t: Type, u: Type | null): boolean {
+  if (u === null) {
+    return false
+  }
+  return t.String() === u.String() || t.Implements(u)
+}
+
 class StructType implements Type {
   constructor(
     private _name: string,
@@ -1551,6 +2057,10 @@ class StructType implements Type {
     return Struct
   }
 
+  public Comparable(): boolean {
+    return this._fields.every((field) => field.type.Comparable())
+  }
+
   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)
@@ -1564,7 +2074,7 @@ class StructType implements Type {
     return this._fields.length
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     // Extract package path from full type name (e.g., "main.Person" -> "main")
     const dotIndex = this._name.lastIndexOf('.')
     if (dotIndex > 0) {
@@ -1591,11 +2101,23 @@ class StructType implements Type {
     const f = this._fields[i]
     return new StructField({
       Name: f.name,
+      PkgPath: '',
       Type: f.type,
       Tag: f.tag ? new StructTag(f.tag) : undefined,
+      Index: [i],
     })
   }
 
+  public FieldByName(name: string): [StructField, boolean] {
+    return typeFieldByName(this, name)
+  }
+
+  public FieldByNameFunc(
+    match: (name: string) => boolean,
+  ): [StructField, boolean] {
+    return typeFieldByNameFunc(this, match)
+  }
+
   public Key(): Type {
     throw new Error('reflect: Key of non-map type')
   }
@@ -1610,6 +2132,10 @@ class StructType implements Type {
     return typeImplementsInterface(this._name, u)
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public common?(): rtype {
     return new rtype(this.Kind())
   }
@@ -1629,7 +2155,15 @@ class StructType implements Type {
   }
 
   public NumMethod(): number {
-    return 0
+    return typeMethods(this).length
+  }
+
+  public MethodByName(name: string): [Method, boolean] {
+    return typeMethodByName(this, name)
+  }
+
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on struct Type')
   }
 
   public Bits(): number {
@@ -1651,6 +2185,10 @@ class StructType implements Type {
           return new BasicType(Bool, 'bool', 1)
         case 'float64':
           return new BasicType(Float64, ti, 8)
+        case 'complex64':
+          return new BasicType(Complex64, ti, 8)
+        case 'complex128':
+          return new BasicType(Complex128, ti, 16)
         case 'uint':
         case 'uint32':
         case 'uint64':
@@ -1661,24 +2199,34 @@ class StructType implements Type {
     } else if (ti && ti.kind) {
       // Handle TypeInfo objects from the builtin type system
       const name = ti.name || 'unknown'
+      const typeName = ti.typeName || ''
       switch (ti.kind) {
         case 'basic':
           // Map TypeScript type names to Go type names
           switch (name) {
             case 'string':
-              return new BasicType(String, 'string', 16)
+              return new BasicType(String, 'string', 16, typeName)
             case 'number':
             case 'int':
             case 'int32':
             case 'int64':
-              return new BasicType(Int, name === 'number' ? 'int' : name, 8)
+              return new BasicType(
+                Int,
+                name === 'number' ? 'int' : name,
+                8,
+                typeName,
+              )
             case 'boolean':
             case 'bool':
-              return new BasicType(Bool, 'bool', 1)
+              return new BasicType(Bool, 'bool', 1, typeName)
             case 'float64':
-              return new BasicType(Float64, 'float64', 8)
+              return new BasicType(Float64, 'float64', 8, typeName)
+            case 'complex64':
+              return new BasicType(Complex64, 'complex64', 8, typeName)
+            case 'complex128':
+              return new BasicType(Complex128, 'complex128', 16, typeName)
             default:
-              return new BasicType(Invalid, name, 8)
+              return new BasicType(Invalid, name, 8, typeName)
           }
         case 'slice':
           if (ti.elemType) {
@@ -1697,7 +2245,7 @@ class StructType implements Type {
         case 'interface':
           return new InterfaceType(name)
         case 'struct':
-          return new StructType(name, [])
+          return new StructType(name, structFieldsFromTypeInfo(ti))
         default:
           return new BasicType(Invalid, name, 8)
       }
@@ -1706,6 +2254,24 @@ class StructType implements Type {
   }
 }
 
+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,
+      }
+    }
+    return {
+      name,
+      type: typeFromTypeInfo(fieldInfo),
+    }
+  })
+}
+
 class ChannelType implements Type {
   constructor(
     private _elemType: Type,
@@ -1730,6 +2296,10 @@ class ChannelType implements Type {
     return Chan
   }
 
+  public Comparable(): boolean {
+    return true
+  }
+
   public Size(): number {
     // Channels are represented as pointers, so pointer size
     return 8
@@ -1743,7 +2313,7 @@ class ChannelType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1756,6 +2326,16 @@ class ChannelType implements Type {
     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 Key(): Type {
     throw new Error('reflect: Key of non-map type')
   }
@@ -1770,6 +2350,10 @@ class ChannelType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public common?(): rtype {
     return new rtype(this.Kind())
   }
@@ -1793,6 +2377,13 @@ class ChannelType implements Type {
   public NumMethod(): number {
     return 0
   }
+  public MethodByName(_name: string): [Method, boolean] {
+    return [zeroMethod(), false]
+  }
+
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on chan Type')
+  }
 
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on chan Type')
@@ -1814,6 +2405,10 @@ class InterfaceType implements Type {
     return Interface
   }
 
+  public Comparable(): boolean {
+    return true
+  }
+
   public Size(): number {
     return 16
   }
@@ -1826,11 +2421,8 @@ class InterfaceType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
-    if (
-      this._name === 'interface{}' ||
-      this._name.startsWith('interface {')
-    ) {
+  public PkgPath(): string {
+    if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
       return ''
     }
     const dotIndex = this._name.lastIndexOf('.')
@@ -1841,10 +2433,7 @@ class InterfaceType implements Type {
   }
 
   public Name(): string {
-    if (
-      this._name === 'interface{}' ||
-      this._name.startsWith('interface {')
-    ) {
+    if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
       return this._name
     }
     const dotIndex = this._name.lastIndexOf('.')
@@ -1858,6 +2447,16 @@ class InterfaceType implements Type {
     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 Key(): Type {
     throw new Error('reflect: Key of non-map type')
   }
@@ -1866,6 +2465,10 @@ class InterfaceType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return typeAssignableTo(this, u)
+  }
+
   public common?(): rtype {
     return new rtype(this.Kind())
   }
@@ -1889,7 +2492,15 @@ class InterfaceType implements Type {
   }
 
   public NumMethod(): number {
-    return 0
+    return typeMethods(this).length
+  }
+
+  public MethodByName(name: string): [Method, boolean] {
+    return typeMethodByName(this, name)
+  }
+
+  public Len(): number {
+    throw new Error('reflect: call of reflect.Type.Len on interface Type')
   }
 
   public Bits(): number {
@@ -2003,6 +2614,15 @@ function getTypeOf(value: ReflectValue): Type {
         return new PointerType(elemType)
       }
 
+      if (
+        'real' in value &&
+        'imag' in value &&
+        typeof (value as $.Complex).real === 'number' &&
+        typeof (value as $.Complex).imag === 'number'
+      ) {
+        return new BasicType(Complex128, 'complex128', 16)
+      }
+
       // Check for arrays
       if (globalThis.Array.isArray(value)) {
         if (value.length === 0) {
@@ -2101,7 +2721,7 @@ function getTypeOf(value: ReflectValue): Type {
                 // Check if fieldInfo is a StructFieldInfo with type and tag
                 if (isStructFieldInfo(fieldInfo)) {
                   return {
-                    name,
+                    name: fieldInfo.name ?? name,
                     type: StructType.createTypeFromFieldInfo(fieldInfo.type),
                     tag: fieldInfo.tag,
                   }
@@ -2134,24 +2754,35 @@ function getTypeOf(value: ReflectValue): Type {
 
 // Exported functions as required by godoc.txt
 export function TypeOf(i: ReflectValue): Type {
-  return getTypeOf(i)
+  return internType(getTypeOf(i))
 }
 
 export function ValueOf(i: ReflectValue): Value {
   return new Value(i, getTypeOf(i))
 }
 
+export function TypeAssert(
+  typeArgs: $.GenericTypeArgs | undefined,
+  v: Value,
+): [any, boolean] {
+  const descriptor = typeArgs?.T
+  if (!descriptor?.type) {
+    return [v.Interface(), true]
+  }
+  return $.typeAssertTuple<any>(v.Interface(), descriptor.type)
+}
+
 export function ArrayOf(length: number, elem: Type): Type {
-  return new ArrayType(elem, length)
+  return internType(new ArrayType(elem, length))
 }
 
 export function SliceOf(t: Type): Type {
-  return new SliceType(t)
+  return internType(new SliceType(t))
 }
 
 export function PointerTo(t: Type | null): Type | null {
   if (t === null) return null
-  return new PointerType(t)
+  return internType(new PointerType(t))
 }
 
 export function PtrTo(t: Type | null): Type | null {
@@ -2159,66 +2790,98 @@ export function PtrTo(t: Type | null): Type | null {
 }
 
 export function MapOf(key: Type, elem: Type): Type {
-  return new MapType(key, elem)
+  return internType(new MapType(key, elem))
 }
 
 export function ChanOf(dir: ChanDir, t: Type): Type {
-  return new ChannelType(t, dir)
+  return internType(new ChannelType(t, dir))
 }
 
 export function TypeFor(typeArgs?: $.GenericTypeArgs): Type {
   const descriptor = typeArgs?.T
   if (descriptor?.type) {
-    return typeFromTypeInfo(descriptor.type)
+    return internType(typeFromTypeInfo(descriptor.type))
   }
   if (descriptor?.methods) {
     const methods = Object.keys(descriptor.methods)
     if (methods.length !== 0) {
-      return new InterfaceType(
-        `interface { ${methods.map((method) => method + '()').join('; ')} }`,
+      return internType(
+        new InterfaceType(
+          `interface { ${methods.map((method) => method + '()').join('; ')} }`,
+        ),
       )
     }
   }
   if (descriptor?.zero) {
-    return getTypeOf(descriptor.zero())
+    return internType(getTypeOf(descriptor.zero()))
   }
-  return new InterfaceType('interface{}')
+  return internType(new InterfaceType('interface{}'))
 }
 
 function typeFromTypeInfo(info: $.TypeInfo | string): Type {
   if (typeof info === 'string') {
     const registered = builtinGetTypeByName(info)
     if (registered) {
-      return typeFromTypeInfo(registered)
+      return internType(typeFromTypeInfo(registered))
     }
-    return StructType.createTypeFromFieldInfo(info)
+    return internType(StructType.createTypeFromFieldInfo(info))
   }
   switch (info.kind) {
     case $.TypeKind.Array:
-      return new ArrayType(
-        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
-        info.length,
+      return internType(
+        new ArrayType(
+          typeFromTypeInfo(
+            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+          info.length,
+        ),
       )
+    case $.TypeKind.Basic:
+      return internType(StructType.createTypeFromFieldInfo(info))
     case $.TypeKind.Channel:
-      return new ChannelType(
-        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
-        chanDirFromTypeInfo(info.direction),
+      return internType(
+        new ChannelType(
+          typeFromTypeInfo(
+            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+          chanDirFromTypeInfo(info.direction),
+        ),
       )
     case $.TypeKind.Function:
-      return functionTypeFromInfo(info)
+      return internType(functionTypeFromInfo(info))
     case $.TypeKind.Interface:
-      return interfaceTypeFromInfo(info)
+      return internType(interfaceTypeFromInfo(info))
     case $.TypeKind.Map:
-      return new MapType(
-        typeFromTypeInfo(info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
-        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+      return internType(
+        new MapType(
+          typeFromTypeInfo(
+            info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+          typeFromTypeInfo(
+            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+        ),
+      )
+    case $.TypeKind.Slice:
+      return internType(
+        new SliceType(
+          typeFromTypeInfo(
+            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+        ),
       )
+    case $.TypeKind.Struct:
+      return internType(StructType.createTypeFromFieldInfo(info))
     case $.TypeKind.Pointer:
-      return new PointerType(
-        typeFromTypeInfo(info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' }),
+      return internType(
+        new PointerType(
+          typeFromTypeInfo(
+            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+        ),
       )
     default:
-      return StructType.createTypeFromFieldInfo(info)
+      return internType(StructType.createTypeFromFieldInfo(info))
   }
 }