goscript 0.0.61 → 0.0.62

package/gs/reflect/type.ts

@@ -1,9 +1,16 @@
-import { ReflectValue, StructField } from './types.js'
+import { ReflectValue, StructField, StructTag, ValueError } from './types.js'
+export { StructField }
 import { MapIter } from './map.js'
 import {
   getTypeByName as builtinGetTypeByName,
   TypeKind,
+  isStructTypeInfo,
+  isInterfaceTypeInfo,
+  isStructFieldInfo,
 } from '../builtin/type.js'
+import { Zero } from './value.js'
+import { DeepEqual } from './deepequal.js'
+import * as $ from '../builtin/index.js'
 
 // rtype is the common implementation of most values
 export class rtype {
@@ -177,7 +184,8 @@ export interface Type {
   Size(): number
 
   // Elem returns a type's element type.
-  Elem(): Type | null
+  // Panics if the type's Kind is not Array, Chan, Map, Pointer, or Slice.
+  Elem(): Type
 
   // NumField returns a struct type's field count.
   NumField(): number
@@ -186,27 +194,113 @@ export interface Type {
   PkgPath?(): string
 
   // Field returns a struct type's i'th field.
-  Field?(i: number): StructField | null
+  // Panics if the type's Kind is not Struct or i is out of range.
+  Field(i: number): StructField
 
-  // Key returns a map type's key type (returns null for non-map types).
-  Key?(): Type | null
+  // Key returns a map type's key type.
+  // Panics if the type's Kind is not Map.
+  Key(): Type
 
   // Name returns the type's name within its package.
-  Name?(): string
+  Name(): string
 
   // Implements reports whether the type implements the interface type u.
-  Implements?(u: Type): boolean
+  Implements(u: Type | null): boolean
 
   // common returns the common type implementation.
   common?(): rtype
+
+  // OverflowInt reports whether the int64 x cannot be represented by the type
+  // Panics if the type's Kind is not Int, Int8, Int16, Int32, or Int64.
+  OverflowInt(x: number): boolean
+
+  // OverflowUint reports whether the uint64 x cannot be represented by the type
+  // Panics if the type's Kind is not Uint, Uint8, Uint16, Uint32, Uint64, or Uintptr.
+  OverflowUint(x: number): boolean
+
+  // OverflowFloat reports whether the float64 x cannot be represented by the type
+  // Panics if the type's Kind is not Float32 or Float64.
+  OverflowFloat(x: number): boolean
+
+  // NumMethod returns the number of methods in the type's method set
+  NumMethod(): number
+
+  // Bits returns the size of the type in bits
+  // Panics if the type's Kind is not a sized type.
+  Bits(): number
+}
+
+// InvalidTypeInstance is a singleton type for invalid/zero reflect.Value
+class InvalidTypeClass implements Type {
+  Kind(): Kind {
+    return Invalid
+  }
+  String(): string {
+    return '<invalid reflect.Value>'
+  }
+  Name(): string {
+    return ''
+  }
+  Size(): number {
+    return 0
+  }
+  Elem(): Type {
+    throw new Error('reflect: Elem of invalid type')
+  }
+  Key(): Type {
+    throw new Error('reflect: Key of invalid type')
+  }
+  NumField(): number {
+    return 0
+  }
+  Field(_i: number): StructField {
+    throw new Error('reflect: Field of invalid type')
+  }
+  Implements(_u: Type | null): boolean {
+    return false
+  }
+  OverflowInt(_x: number): boolean {
+    throw new Error('reflect: OverflowInt of invalid type')
+  }
+  OverflowUint(_x: number): boolean {
+    throw new Error('reflect: OverflowUint of invalid type')
+  }
+  OverflowFloat(_x: number): boolean {
+    throw new Error('reflect: OverflowFloat of invalid type')
+  }
+  NumMethod(): number {
+    return 0
+  }
+  Bits(): number {
+    throw new Error('reflect: Bits of invalid type')
+  }
 }
+const invalidTypeInstance = new InvalidTypeClass()
 
 // Value is the reflection interface to a Go value - consolidated from all implementations
 export class Value {
-  constructor(
-    private _value: ReflectValue,
-    private _type: Type,
-  ) {}
+  private _value: ReflectValue
+  private _type: Type
+
+  constructor(value?: ReflectValue | Record<string, never>, type?: Type | null) {
+    // Handle zero-value initialization: new Value({}) or new Value()
+    // This corresponds to reflect.Value{} in Go which is an invalid/zero value
+    if (
+      type === undefined ||
+      type === null ||
+      (typeof value === 'object' &&
+        value !== null &&
+        Object.keys(value).length === 0 &&
+        !(value instanceof globalThis.Array) &&
+        !(value instanceof globalThis.Map))
+    ) {
+      this._value = null
+      this._type = invalidTypeInstance
+    } else {
+      this._value = value as ReflectValue
+      this._type = type
+    }
+  }
 
   public clone(): Value {
     return new Value(this._value, this._type)
@@ -359,9 +453,21 @@ export class Value {
     return this._type.NumField()
   }
 
-  public Field(_i: number): Value {
-    // Simplified implementation for struct field access
-    return new Value(null, this._type)
+  public Field(i: number): Value {
+    if (this.Kind() !== Struct) {
+      throw new ValueError({ Kind: this.Kind(), Method: 'Field' })
+    }
+
+    const field = this.Type().Field(i)
+    if (!field) {
+      throw new Error('reflect: struct field index out of range')
+    }
+
+    let fieldVal = (this._value as Record<string, any>)[field.Name]
+    if (fieldVal === undefined) {
+      fieldVal = null
+    }
+    return new Value(fieldVal, field.Type)
   }
 
   // Additional methods needed by various parts of the codebase
@@ -388,7 +494,42 @@ export class Value {
     return new Value(this._value, t)
   }
 
+  public CanAddr(): boolean {
+    return this.Kind() !== Ptr && this._value !== null // Simplified
+  }
+
+  public Addr(): Value {
+    if (!this.CanAddr()) {
+      throw new Error('reflect: call of reflect.Value.Addr on invalid Value')
+    }
+    const ptrType = PointerTo(this.Type())
+    return new Value(this, ptrType) // Simplified
+  }
+
+  public CanSet(): boolean {
+    return this.IsValid() && this.Kind() !== Ptr // Simplified
+  }
+
+  public Set(x: Value): void {
+    if (!this.CanSet()) {
+      throw new Error('reflect: assign to invalid value')
+    }
+    if (this.Type() !== x.Type()) {
+      throw new Error('reflect: assign to wrong type')
+    }
+    this._value = x.value
+  }
+
   // Additional methods from deleted reflect.gs.ts
+  public Interface(): any {
+    return this._value
+  }
+
+  public IsZero(): boolean {
+    const zeroVal = Zero(this.Type()).value
+    return DeepEqual(this._value, zeroVal)
+  }
+
   public typ(): rtype | null {
     return new rtype(this._type.Kind())
   }
@@ -439,6 +580,269 @@ export class Value {
       channelObj._sendQueue.push(valueToSend)
     }
   }
+
+  // SetString sets v's underlying value to x
+  public SetString(x: string): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetString on unaddressable value',
+      )
+    }
+    if (this.Kind() !== String) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetString on ' + this.Kind() + ' Value',
+      )
+    }
+    this._value = x
+  }
+
+  // SetInt sets v's underlying value to x
+  public SetInt(x: number): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetInt on unaddressable value',
+      )
+    }
+    const k = this.Kind()
+    if (k !== Int && k !== Int8 && k !== Int16 && k !== Int32 && k !== Int64) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetInt on ' + k + ' Value',
+      )
+    }
+    this._value = x
+  }
+
+  // SetUint sets v's underlying value to x
+  public SetUint(x: number): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetUint on unaddressable value',
+      )
+    }
+    const k = this.Kind()
+    if (
+      k !== Uint &&
+      k !== Uint8 &&
+      k !== Uint16 &&
+      k !== Uint32 &&
+      k !== Uint64 &&
+      k !== Uintptr
+    ) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetUint on ' + k + ' Value',
+      )
+    }
+    this._value = x
+  }
+
+  // SetBool sets v's underlying value to x
+  public SetBool(x: boolean): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetBool on unaddressable value',
+      )
+    }
+    if (this.Kind() !== Bool) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetBool on ' + this.Kind() + ' Value',
+      )
+    }
+    this._value = x
+  }
+
+  // SetFloat sets v's underlying value to x
+  public SetFloat(x: number): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetFloat on unaddressable value',
+      )
+    }
+    const k = this.Kind()
+    if (k !== Float32 && k !== Float64) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetFloat on ' + k + ' Value',
+      )
+    }
+    this._value = x
+  }
+
+  // SetBytes sets v's underlying value to x
+  public SetBytes(x: $.Slice<number>): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetBytes on unaddressable value',
+      )
+    }
+    if (this.Kind() !== Slice) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetBytes on ' + this.Kind() + ' Value',
+      )
+    }
+    // Convert Uint8Array or slice to array
+    if (x instanceof Uint8Array) {
+      this._value = globalThis.Array.from(x)
+    } else if (globalThis.Array.isArray(x)) {
+      this._value = x
+    } else {
+      this._value = x
+    }
+  }
+
+  // SetZero sets v to be the zero value of v's type
+  public SetZero(): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetZero on unaddressable value',
+      )
+    }
+    const zeroVal = Zero(this.Type())
+    this._value = (zeroVal as unknown as { value: ReflectValue }).value
+  }
+
+  // SetLen sets v's length to n
+  public SetLen(n: number): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetLen on unaddressable value',
+      )
+    }
+    if (this.Kind() !== Slice) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetLen on ' + this.Kind() + ' Value',
+      )
+    }
+    if (globalThis.Array.isArray(this._value)) {
+      this._value.length = n
+    }
+  }
+
+  // SetMapIndex sets the element associated with key in the map v to elem
+  public SetMapIndex(key: Value, elem: Value): void {
+    if (!this.CanSet()) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetMapIndex on unaddressable value',
+      )
+    }
+    if (this.Kind() !== Map) {
+      throw new Error(
+        'reflect: call of reflect.Value.SetMapIndex on ' +
+          this.Kind() +
+          ' Value',
+      )
+    }
+    const mapObj = this._value as globalThis.Map<unknown, unknown>
+    const keyVal = (key as unknown as { value: ReflectValue }).value
+    const elemVal = (elem as unknown as { value: ReflectValue }).value
+    mapObj.set(keyVal, elemVal)
+  }
+
+  // Grow increases the slice's capacity, if necessary
+  public Grow(n: number): void {
+    if (this.Kind() !== Slice) {
+      throw new Error(
+        'reflect: call of reflect.Value.Grow on ' + this.Kind() + ' Value',
+      )
+    }
+    if (!globalThis.Array.isArray(this._value)) {
+      return
+    }
+    // JavaScript arrays grow automatically, but we ensure capacity
+    const currentLen = this._value.length
+    const targetCap = currentLen + n
+    if (this._value.length < targetCap) {
+      this._value.length = targetCap
+      this._value.length = currentLen // Reset to original length
+    }
+  }
+
+  // Cap returns v's capacity
+  public Cap(): number {
+    const k = this.Kind()
+    if (k === Slice || k === Array) {
+      if (globalThis.Array.isArray(this._value)) {
+        return this._value.length
+      }
+      return 0
+    }
+    if (k === Chan) {
+      return 0 // Simplified
+    }
+    throw new Error('reflect: call of reflect.Value.Cap on ' + k + ' Value')
+  }
+
+  // NumMethod returns the number of methods in the value's method set
+  public NumMethod(): number {
+    return 0 // Simplified - methods not fully implemented
+  }
+
+  // Equal reports whether v is equal to u
+  public Equal(u: Value): boolean {
+    return DeepEqual(
+      this._value,
+      (u as unknown as { value: ReflectValue }).value,
+    )
+  }
+
+  // CanInterface reports whether Interface can be used without panicking
+  public CanInterface(): boolean {
+    return this.IsValid()
+  }
+
+  // OverflowInt reports whether the int64 x cannot be represented by v's type
+  public OverflowInt(x: number): boolean {
+    const k = this.Kind()
+    switch (k) {
+      case Int8:
+        return x < -128 || x > 127
+      case Int16:
+        return x < -32768 || x > 32767
+      case Int32:
+        return x < -2147483648 || x > 2147483647
+      case Int:
+      case Int64:
+        return x < Number.MIN_SAFE_INTEGER || x > Number.MAX_SAFE_INTEGER
+      default:
+        throw new Error(
+          'reflect: call of reflect.Value.OverflowInt on ' + k + ' Value',
+        )
+    }
+  }
+
+  // OverflowUint reports whether the uint64 x cannot be represented by v's type
+  public OverflowUint(x: number): boolean {
+    const k = this.Kind()
+    switch (k) {
+      case Uint8:
+        return x < 0 || x > 255
+      case Uint16:
+        return x < 0 || x > 65535
+      case Uint32:
+        return x < 0 || x > 4294967295
+      case Uint:
+      case Uint64:
+      case Uintptr:
+        return x < 0 || x > Number.MAX_SAFE_INTEGER
+      default:
+        throw new Error(
+          'reflect: call of reflect.Value.OverflowUint on ' + k + ' Value',
+        )
+    }
+  }
+
+  // OverflowFloat reports whether the float64 x cannot be represented by v's type
+  public OverflowFloat(x: number): boolean {
+    const k = this.Kind()
+    if (k === Float32) {
+      const f32max = 3.4028234663852886e38
+      return Math.abs(x) > f32max && !isNaN(x) && !!isFinite(x)
+    }
+    if (k === Float64) {
+      return false // float64 can represent any JavaScript number
+    }
+    throw new Error(
+      'reflect: call of reflect.Value.OverflowFloat on ' + k + ' Value',
+    )
+  }
 }
 
 // Basic type implementation - exported for compatibility
@@ -461,8 +865,8 @@ export class BasicType implements Type {
     return this._size
   }
 
-  public Elem(): Type | null {
-    return null
+  public Elem(): Type {
+    throw new Error(`reflect: Elem of invalid type ${this._name}`)
   }
 
   public NumField(): number {
@@ -473,13 +877,125 @@ export class BasicType implements Type {
     return ''
   }
 
-  public Field?(_i: number): StructField | null {
-    return null
+  public Name(): string {
+    // Basic types have names like 'int', 'string', etc.
+    return this._name
+  }
+
+  public Field(_i: number): StructField {
+    throw new Error(`reflect: Field of non-struct type ${this._name}`)
+  }
+
+  public Key(): Type {
+    throw new Error(`reflect: Key of non-map type ${this._name}`)
+  }
+
+  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 false
   }
 
   public common?(): rtype {
     return new rtype(this._kind)
   }
+
+  public OverflowInt(x: number): boolean {
+    const k = this._kind
+    switch (k) {
+      case Int8:
+        return x < -128 || x > 127
+      case Int16:
+        return x < -32768 || x > 32767
+      case Int32:
+        return x < -2147483648 || x > 2147483647
+      case Int:
+      case Int64:
+        return x < Number.MIN_SAFE_INTEGER || x > Number.MAX_SAFE_INTEGER
+      default:
+        throw new Error(
+          'reflect: call of reflect.Type.OverflowInt on ' +
+            Kind_String(k) +
+            ' Type',
+        )
+    }
+  }
+
+  public OverflowUint(x: number): boolean {
+    const k = this._kind
+    switch (k) {
+      case Uint8:
+        return x < 0 || x > 255
+      case Uint16:
+        return x < 0 || x > 65535
+      case Uint32:
+        return x < 0 || x > 4294967295
+      case Uint:
+      case Uint64:
+      case Uintptr:
+        return x < 0 || x > Number.MAX_SAFE_INTEGER
+      default:
+        throw new Error(
+          'reflect: call of reflect.Type.OverflowUint on ' +
+            Kind_String(k) +
+            ' Type',
+        )
+    }
+  }
+
+  public OverflowFloat(x: number): boolean {
+    const k = this._kind
+    if (k === Float32) {
+      const f32max = 3.4028234663852886e38
+      return Math.abs(x) > f32max && !isNaN(x) && !!isFinite(x)
+    }
+    if (k === Float64) {
+      return false
+    }
+    throw new Error(
+      'reflect: call of reflect.Type.OverflowFloat on ' +
+        Kind_String(k) +
+        ' Type',
+    )
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    const k = this._kind
+    switch (k) {
+      case Bool:
+        return 1
+      case Int8:
+      case Uint8:
+        return 8
+      case Int16:
+      case Uint16:
+        return 16
+      case Int32:
+      case Uint32:
+      case Float32:
+        return 32
+      case Int64:
+      case Uint64:
+      case Float64:
+        return 64
+      case Int:
+      case Uint:
+      case Uintptr:
+        return 64 // Assuming 64-bit architecture
+      default:
+        throw new Error(
+          'reflect: call of reflect.Type.Bits on ' + Kind_String(k) + ' Type',
+        )
+    }
+  }
 }
 
 // Slice type implementation
@@ -498,7 +1014,7 @@ class SliceType implements Type {
     return 24 // slice header size
   }
 
-  public Elem(): Type | null {
+  public Elem(): Type {
     return this._elemType
   }
 
@@ -509,6 +1025,49 @@ class SliceType implements Type {
   public PkgPath?(): string {
     return ''
   }
+
+  public Name(): string {
+    // Slice types are unnamed composite types
+    return ''
+  }
+
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type')
+  }
+
+  public Key(): Type {
+    throw new Error('reflect: Key of non-map type')
+  }
+
+  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 false
+  }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowInt on slice Type')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowUint on slice Type')
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowFloat on slice Type')
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: call of reflect.Type.Bits on slice Type')
+  }
 }
 
 // Array type implementation
@@ -530,7 +1089,7 @@ class ArrayType implements Type {
     return this._elemType.Size() * this._len
   }
 
-  public Elem(): Type | null {
+  public Elem(): Type {
     return this._elemType
   }
 
@@ -546,13 +1105,52 @@ class ArrayType implements Type {
     return ''
   }
 
-  public Field?(_i: number): StructField | null {
-    return null
+  public Name(): string {
+    // Array types are unnamed composite types
+    return ''
+  }
+
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type')
+  }
+
+  public Key(): Type {
+    throw new Error('reflect: Key of non-map type')
+  }
+
+  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 false
   }
 
   public common?(): rtype {
     return new rtype(this.Kind())
   }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowInt on array Type')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowUint on array Type')
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowFloat on array Type')
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: call of reflect.Type.Bits on array Type')
+  }
 }
 
 // Pointer type implementation
@@ -571,7 +1169,7 @@ class PointerType implements Type {
     return 8 // pointer size
   }
 
-  public Elem(): Type | null {
+  public Elem(): Type {
     return this._elemType
   }
 
@@ -583,13 +1181,58 @@ class PointerType implements Type {
     return ''
   }
 
-  public Field?(_i: number): StructField | null {
-    return null
+  public Name(): string {
+    // Pointer types are unnamed composite types
+    return ''
+  }
+
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type')
+  }
+
+  public Key(): Type {
+    throw new Error('reflect: Key of non-map type')
+  }
+
+  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')
+    }
+    // For pointer types, check if the element type implements the interface
+    const elemTypeName = this._elemType.String()
+    return typeImplementsInterface(elemTypeName, u)
   }
 
   public common?(): rtype {
     return new rtype(this.Kind())
   }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowInt on pointer Type')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error(
+      'reflect: call of reflect.Type.OverflowUint on pointer Type',
+    )
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error(
+      'reflect: call of reflect.Type.OverflowFloat on pointer Type',
+    )
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: call of reflect.Type.Bits on pointer Type')
+  }
 }
 
 // Function type implementation
@@ -608,8 +1251,8 @@ class FunctionType implements Type {
     return 8 // function pointer size
   }
 
-  public Elem(): Type | null {
-    return null
+  public Elem(): Type {
+    throw new Error('reflect: Elem of invalid type')
   }
 
   public NumField(): number {
@@ -620,13 +1263,52 @@ class FunctionType implements Type {
     return ''
   }
 
-  public Field?(_i: number): StructField | null {
-    return null
+  public Name(): string {
+    // Function types are unnamed composite types
+    return ''
+  }
+
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type')
+  }
+
+  public Key(): Type {
+    throw new Error('reflect: Key of non-map type')
+  }
+
+  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 false
   }
 
   public common?(): rtype {
     return new rtype(this.Kind())
   }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowInt on func Type')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowUint on func Type')
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowFloat on func Type')
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: call of reflect.Type.Bits on func Type')
+  }
 }
 
 // Map type implementation
@@ -648,7 +1330,7 @@ class MapType implements Type {
     return 8 // map header size
   }
 
-  public Elem(): Type | null {
+  public Elem(): Type {
     return this._elemType
   }
 
@@ -664,20 +1346,109 @@ class MapType implements Type {
     return ''
   }
 
-  public Field?(_i: number): StructField | null {
-    return null
+  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 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 false
   }
 
   public common?(): rtype {
     return new rtype(this.Kind())
   }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowInt on map Type')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowUint on map Type')
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowFloat on map Type')
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: call of reflect.Type.Bits on map 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.String()
+  const interfaceTypeInfo = builtinGetTypeByName(interfaceName)
+
+  if (!interfaceTypeInfo || !isInterfaceTypeInfo(interfaceTypeInfo)) {
+    return false
+  }
+
+  // Get the type info for the struct/type
+  const typeInfo = builtinGetTypeByName(typeName)
+
+  if (!typeInfo || !isStructTypeInfo(typeInfo)) {
+    return false
+  }
+
+  // Check if the type has all required methods
+  const requiredMethods = interfaceTypeInfo.methods || []
+  const typeMethods = typeInfo.methods || []
+
+  // 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)
+
+    if (!typeMethod) {
+      return false
+    }
+
+    // Check if method signatures match (simplified - just check counts)
+    if (typeMethod.args.length !== requiredMethod.args.length) {
+      return false
+    }
+
+    if (typeMethod.returns.length !== requiredMethod.returns.length) {
+      return false
+    }
+
+    // Could add deeper type checking here, but for now this is sufficient
+  }
+
+  return true
+}
+
 class StructType implements Type {
   constructor(
     private _name: string,
-    private _fields: Array<{ name: string; type: Type }> = [],
+    private _fields: Array<{ name: string; type: Type; tag?: string }> = [],
   ) {}
 
   public String(): string {
@@ -693,8 +1464,8 @@ class StructType implements Type {
     return this._fields.reduce((sum, field) => sum + field.type.Size(), 0)
   }
 
-  public Elem(): Type | null {
-    return null
+  public Elem(): Type {
+    throw new Error('reflect: Elem of invalid type')
   }
 
   public NumField(): number {
@@ -702,17 +1473,139 @@ class StructType implements Type {
   }
 
   public PkgPath?(): string {
+    // Extract package path from full type name (e.g., "main.Person" -> "main")
+    const dotIndex = this._name.lastIndexOf('.')
+    if (dotIndex > 0) {
+      return this._name.substring(0, dotIndex)
+    }
     return ''
   }
 
-  public Field?(_i: number): any {
-    // Stub implementation
-    return null
+  public Name(): string {
+    // Extract type name from full type name (e.g., "main.Person" -> "Person")
+    const dotIndex = this._name.lastIndexOf('.')
+    if (dotIndex >= 0) {
+      return this._name.substring(dotIndex + 1)
+    }
+    return this._name
+  }
+
+  public Field(i: number): StructField {
+    if (i < 0 || i >= this.NumField()) {
+      throw new Error(`reflect: Field index out of range [${i}] with length ${this.NumField()}`)
+    }
+    const f = this._fields[i]
+    return new StructField({
+      Name: f.name,
+      Type: f.type,
+      Tag: f.tag ? new StructTag(f.tag) : undefined,
+    })
+  }
+
+  public Key(): Type {
+    throw new Error('reflect: Key of non-map type')
+  }
+
+  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._name, u)
   }
 
   public common?(): rtype {
     return new rtype(this.Kind())
   }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowInt on struct Type')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowUint on struct Type')
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error(
+      'reflect: call of reflect.Type.OverflowFloat on struct Type',
+    )
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: call of reflect.Type.Bits on struct Type')
+  }
+
+  static createTypeFromFieldInfo(ti: any): Type {
+    if (typeof ti === 'string') {
+      switch (ti) {
+        case 'string':
+          return new BasicType(String, ti, 16)
+        case 'int':
+        case 'int32':
+        case 'int64':
+        case 'number':
+          return new BasicType(Int, ti === 'number' ? 'int' : ti, 8)
+        case 'bool':
+        case 'boolean':
+          return new BasicType(Bool, 'bool', 1)
+        case 'float64':
+          return new BasicType(Float64, ti, 8)
+        case 'uint':
+        case 'uint32':
+        case 'uint64':
+          return new BasicType(Uint, ti, 8)
+        default:
+          return new BasicType(Invalid, ti, 8)
+      }
+    } else if (ti && ti.kind) {
+      // Handle TypeInfo objects from the builtin type system
+      const name = ti.name || 'unknown'
+      switch (ti.kind) {
+        case 'basic':
+          // Map TypeScript type names to Go type names
+          switch (name) {
+            case 'string':
+              return new BasicType(String, 'string', 16)
+            case 'number':
+            case 'int':
+            case 'int32':
+            case 'int64':
+              return new BasicType(Int, name === 'number' ? 'int' : name, 8)
+            case 'boolean':
+            case 'bool':
+              return new BasicType(Bool, 'bool', 1)
+            case 'float64':
+              return new BasicType(Float64, 'float64', 8)
+            default:
+              return new BasicType(Invalid, name, 8)
+          }
+        case 'slice':
+          if (ti.elemType) {
+            return new SliceType(StructType.createTypeFromFieldInfo(ti.elemType))
+          }
+          return new SliceType(new BasicType(Invalid, 'unknown', 8))
+        case 'pointer':
+          if (ti.elemType) {
+            return new PointerType(StructType.createTypeFromFieldInfo(ti.elemType))
+          }
+          return new PointerType(new BasicType(Invalid, 'unknown', 8))
+        case 'interface':
+          return new InterfaceType(name)
+        case 'struct':
+          return new StructType(name, [])
+        default:
+          return new BasicType(Invalid, name, 8)
+      }
+    }
+    return new BasicType(Invalid, 'unknown', 8)
+  }
 }
 
 class ChannelType implements Type {
@@ -744,7 +1637,7 @@ class ChannelType implements Type {
     return 8
   }
 
-  public Elem(): Type | null {
+  public Elem(): Type {
     return this._elemType
   }
 
@@ -756,8 +1649,27 @@ class ChannelType implements Type {
     return ''
   }
 
-  public Field?(_: number): any {
-    return null
+  public Name(): string {
+    // Channel types are unnamed composite types
+    return ''
+  }
+
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type')
+  }
+
+  public Key(): Type {
+    throw new Error('reflect: Key of non-map type')
+  }
+
+  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 false
   }
 
   public common?(): rtype {
@@ -767,6 +1679,26 @@ class ChannelType implements Type {
   public ChanDir(): ChanDir {
     return this._dir
   }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowInt on chan Type')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowUint on chan Type')
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error('reflect: call of reflect.Type.OverflowFloat on chan Type')
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: call of reflect.Type.Bits on chan Type')
+  }
 }
 
 // Interface type implementation
@@ -785,8 +1717,8 @@ class InterfaceType implements Type {
     return 16
   }
 
-  public Elem(): Type | null {
-    return null
+  public Elem(): Type {
+    throw new Error('reflect: Elem of invalid type')
   }
 
   public NumField(): number {
@@ -797,24 +1729,70 @@ class InterfaceType implements Type {
     return ''
   }
 
-  public Name?(): string {
+  public Name(): string {
     return this._name
   }
 
-  public Field?(_: number): StructField | null {
-    return null
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type')
   }
 
-  public Implements?(_u: Type): boolean {
+  public Key(): Type {
+    throw new Error('reflect: Key of non-map type')
+  }
+
+  public Implements(_u: Type | null): boolean {
     return false
   }
 
   public common?(): rtype {
     return new rtype(this.Kind())
   }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error(
+      'reflect: call of reflect.Type.OverflowInt on interface Type',
+    )
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error(
+      'reflect: call of reflect.Type.OverflowUint on interface Type',
+    )
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error(
+      'reflect: call of reflect.Type.OverflowFloat on interface Type',
+    )
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: call of reflect.Type.Bits on interface Type')
+  }
 }
 
 function getTypeOf(value: ReflectValue): Type {
+  // Check for typed nil before checking for plain null
+  // Typed nils are created by $.typedNil() and have __goType and __isTypedNil properties
+  if (value && typeof value === 'object' && (value as any).__isTypedNil) {
+    const typeName = (value as any).__goType
+    if (typeName && typeof typeName === 'string') {
+      // Parse the type name to construct the appropriate Type
+      // For pointer types like "*main.Stringer", extract the element type
+      if (typeName.startsWith('*')) {
+        const elemTypeName = typeName.slice(1) // Remove the '*' prefix
+        // Create an InterfaceType for the element (works for interfaces and other types)
+        const elemType = new InterfaceType(elemTypeName)
+        return new PointerType(elemType)
+      }
+    }
+  }
+
   if (value === null || value === undefined) {
     return new BasicType(Interface, 'interface{}', 16)
   }
@@ -995,23 +1973,43 @@ function getTypeOf(value: ReflectValue): Type {
           value.constructor as { __typeInfo?: { name?: string } }
         ).__typeInfo
         if (typeInfo && typeInfo.name) {
-          // Add package prefix for struct types if not already present
           const typeName =
             typeInfo.name.includes('.') ?
               typeInfo.name
             : `main.${typeInfo.name}`
-          return new StructType(typeName)
+          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,
+                    type: StructType.createTypeFromFieldInfo(fieldInfo.type),
+                    tag: fieldInfo.tag,
+                  }
+                }
+                // Otherwise it's just the type info directly (backwards compatible)
+                return {
+                  name,
+                  type: StructType.createTypeFromFieldInfo(fieldInfo),
+                }
+              },
+            )
+          }
+          return new StructType(typeName, fields)
         }
       }
 
       // Check if it has a constructor name we can use (fallback)
       const constructorName = (value as object).constructor?.name
       if (constructorName && constructorName !== 'Object') {
-        return new StructType(constructorName)
+        return new StructType(constructorName, [])
       }
 
       // Default to struct type for plain objects
-      return new StructType('struct')
+      return new StructType('struct', [])
     }
     default:
       return new BasicType(Interface, 'interface{}', 16)
@@ -1035,11 +2033,12 @@ export function SliceOf(t: Type): Type {
   return new SliceType(t)
 }
 
-export function PointerTo(t: Type): Type {
+export function PointerTo(t: Type | null): Type | null {
+  if (t === null) return null
   return new PointerType(t)
 }
 
-export function PtrTo(t: Type): Type {
+export function PtrTo(t: Type | null): Type | null {
   return PointerTo(t) // PtrTo is an alias for PointerTo
 }
 
@@ -1051,7 +2050,7 @@ export function ChanOf(dir: ChanDir, t: Type): Type {
   return new ChannelType(t, dir)
 }
 
-export function TypeFor<T>(): Type {
+export function TypeFor(): Type {
   return new InterfaceType('interface{}')
 }