goscript 0.1.1 → 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 {
@@ -176,6 +182,7 @@ 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)
@@ -187,6 +194,16 @@ function pointerAddress(value: object): number {
   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.
@@ -206,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
@@ -222,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
 
@@ -240,6 +266,9 @@ 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
@@ -247,6 +276,9 @@ export interface Type {
   // 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
@@ -254,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
   }
@@ -275,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')
   }
@@ -290,6 +337,9 @@ 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')
   }
@@ -479,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
@@ -524,6 +603,22 @@ 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
@@ -568,6 +663,16 @@ export class 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
   }
@@ -596,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 {
@@ -644,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)
@@ -658,13 +800,33 @@ 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 {
-    // Placeholder for map access
-    return new Value(null, new BasicType(Invalid, 'invalid'))
+  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 MapKeys(): $.Slice<Value> {
@@ -1048,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
   }
@@ -1070,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
   }
@@ -1083,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}`)
   }
@@ -1097,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)
   }
@@ -1163,6 +1357,9 @@ 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(
@@ -1219,6 +1416,10 @@ class SliceType implements Type {
     return Slice
   }
 
+  public Comparable(): boolean {
+    return false
+  }
+
   public Size(): number {
     return 24 // slice header size
   }
@@ -1231,7 +1432,7 @@ class SliceType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1244,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')
   }
@@ -1258,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')
   }
@@ -1273,6 +1488,9 @@ 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')
@@ -1298,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
   }
@@ -1314,7 +1536,7 @@ class ArrayType implements Type {
     return this._len
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1327,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')
   }
@@ -1341,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())
   }
@@ -1360,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')
@@ -1378,6 +1617,10 @@ class PointerType implements Type {
     return Ptr
   }
 
+  public Comparable(): boolean {
+    return true
+  }
+
   public Size(): number {
     return 8 // pointer size
   }
@@ -1390,7 +1633,7 @@ class PointerType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1403,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')
   }
@@ -1419,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())
   }
@@ -1442,6 +1699,9 @@ 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')
@@ -1464,6 +1724,10 @@ class FunctionType implements Type {
     return Func
   }
 
+  public Comparable(): boolean {
+    return false
+  }
+
   public Size(): number {
     return 8 // function pointer size
   }
@@ -1476,7 +1740,7 @@ class FunctionType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1489,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')
   }
@@ -1503,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())
   }
@@ -1522,6 +1800,9 @@ 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')
@@ -1547,6 +1828,10 @@ class MapType implements Type {
     return Map
   }
 
+  public Comparable(): boolean {
+    return false
+  }
+
   public Size(): number {
     return 8 // map header size
   }
@@ -1563,7 +1848,7 @@ class MapType implements Type {
     return this._keyType
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1576,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
@@ -1586,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())
   }
@@ -1605,6 +1904,9 @@ 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')
@@ -1673,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,
@@ -1687,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)
@@ -1700,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) {
@@ -1727,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')
   }
@@ -1746,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())
   }
@@ -1765,7 +2155,11 @@ 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 {
@@ -1805,28 +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)
+              return new BasicType(Complex64, 'complex64', 8, typeName)
             case 'complex128':
-              return new BasicType(Complex128, 'complex128', 16)
+              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) {
@@ -1845,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)
       }
@@ -1854,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,
@@ -1878,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
@@ -1891,7 +2313,7 @@ class ChannelType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     return ''
   }
 
@@ -1904,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')
   }
@@ -1918,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())
   }
@@ -1941,6 +2377,9 @@ 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')
@@ -1966,6 +2405,10 @@ class InterfaceType implements Type {
     return Interface
   }
 
+  public Comparable(): boolean {
+    return true
+  }
+
   public Size(): number {
     return 16
   }
@@ -1978,7 +2421,7 @@ class InterfaceType implements Type {
     return 0
   }
 
-  public PkgPath?(): string {
+  public PkgPath(): string {
     if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
       return ''
     }
@@ -2004,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')
   }
@@ -2012,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())
   }
@@ -2035,7 +2492,11 @@ 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 {
@@ -2293,7 +2754,7 @@ 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 {
@@ -2312,16 +2773,16 @@ export function TypeAssert(
 }
 
 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 {
@@ -2329,76 +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' },
+      return internType(
+        new ArrayType(
+          typeFromTypeInfo(
+            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+          info.length,
         ),
-        info.length,
       )
+    case $.TypeKind.Basic:
+      return internType(StructType.createTypeFromFieldInfo(info))
     case $.TypeKind.Channel:
-      return new ChannelType(
-        typeFromTypeInfo(
-          info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+      return internType(
+        new ChannelType(
+          typeFromTypeInfo(
+            info.elemType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+          chanDirFromTypeInfo(info.direction),
         ),
-        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' },
+      return internType(
+        new MapType(
+          typeFromTypeInfo(
+            info.keyType ?? { kind: $.TypeKind.Basic, name: 'unknown' },
+          ),
+          typeFromTypeInfo(
+            info.elemType ?? { 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))
   }
 }