goscript 0.1.0 → 0.1.2

package/dist/gs/reflect/type.js

@@ -1,5 +1,6 @@
-import { StructField, StructTag, ValueError } from './types.js';
+import { 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';
@@ -150,17 +151,45 @@ export const Slice = 23;
 export const String = 24;
 export const Struct = 25;
 export const UnsafePointer = 26;
+const pointerAddressStride = 0x100000000;
+const pointerAddresses = new WeakMap();
+let nextPointerAddress = 1;
+const canonicalTypes = new globalThis.Map();
+function pointerAddress(value) {
+    let address = pointerAddresses.get(value);
+    if (address === undefined) {
+        address = nextPointerAddress * pointerAddressStride;
+        nextPointerAddress++;
+        pointerAddresses.set(value, address);
+    }
+    return address;
+}
+function internType(t) {
+    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;
+}
 // InvalidTypeInstance is a singleton type for invalid/zero reflect.Value
 class InvalidTypeClass {
     Kind() {
         return Invalid;
     }
+    Comparable() {
+        return false;
+    }
     String() {
         return '<invalid reflect.Value>';
     }
     Name() {
         return '';
     }
+    PkgPath() {
+        return '';
+    }
     Size() {
         return 0;
     }
@@ -176,9 +205,18 @@ class InvalidTypeClass {
     Field(_i) {
         throw new Error('reflect: Field of invalid type');
     }
+    FieldByName(_name) {
+        return [new StructField(), false];
+    }
+    FieldByNameFunc(_match) {
+        return [new StructField(), false];
+    }
     Implements(_u) {
         return false;
     }
+    AssignableTo(_u) {
+        return false;
+    }
     OverflowInt(_x) {
         throw new Error('reflect: OverflowInt of invalid type');
     }
@@ -191,6 +229,12 @@ class InvalidTypeClass {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
+    Len() {
+        throw new Error('reflect: Len of invalid type');
+    }
     Bits() {
         throw new Error('reflect: Bits of invalid type');
     }
@@ -329,6 +373,27 @@ export class Value {
             Kind_String(this._type.Kind()) +
             ' Value');
     }
+    Slice(i, j) {
+        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, 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' });
+    }
     Bytes() {
         if (this._value instanceof Uint8Array) {
             return this._value;
@@ -366,10 +431,70 @@ export class Value {
         // Pass parent struct and field name so Set() can update the struct
         return new Value(fieldVal, field.Type, undefined, parentObj, field.Name);
     }
+    FieldByIndex(index) {
+        let current = this;
+        for (const fieldIndex of $.asArray(index)) {
+            current = current.Field(fieldIndex);
+        }
+        return current;
+    }
+    FieldByName(name) {
+        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
     UnsafePointer() {
         return this._value;
     }
+    Pointer() {
+        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;
+            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;
+    }
+    UnsafeAddr() {
+        if (!this.CanAddr()) {
+            throw new ValueError({ Kind: this.Kind(), Method: 'UnsafeAddr' });
+        }
+        if (this._parentStruct && this._fieldName) {
+            return { value: this };
+        }
+        return this.Pointer();
+    }
     pointer() {
         return this._value;
     }
@@ -393,7 +518,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);
     }
     CanSet() {
         // Simplified: all valid values are settable in GoScript since we handle
@@ -437,6 +565,36 @@ export class Value {
     Interface() {
         return this._value;
     }
+    MethodByName(name) {
+        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[name];
+        if (typeof method !== 'function') {
+            return new Value();
+        }
+        return new Value(method.bind(receiver), new FunctionType('func'));
+    }
+    Call(inArgs) {
+        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);
+        if (globalThis.Array.isArray(result)) {
+            return $.arrayToSlice(result.map((value) => ValueOf(value)));
+        }
+        if (result === undefined) {
+            return $.makeSlice(0);
+        }
+        return $.arrayToSlice([ValueOf(result)]);
+    }
     IsZero() {
         const zeroVal = Zero(this.Type()).value;
         return DeepEqual(this._value, zeroVal);
@@ -448,16 +606,56 @@ export class Value {
         return 0;
     }
     MapRange() {
-        // 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);
     }
-    MapIndex(_key) {
-        // Placeholder for map access
-        return new Value(null, new BasicType(Invalid, 'invalid'));
+    MapIndex(key) {
+        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), this.Type().Elem());
+    }
+    MapKeys() {
+        if (this.Kind() !== Map) {
+            throw new ValueError({ Kind: this.Kind(), Method: 'MapKeys' });
+        }
+        if (this._value === null || this._value === undefined) {
+            return $.makeSlice(0);
+        }
+        if (!(this._value instanceof globalThis.Map)) {
+            throw new ValueError({ Kind: this.Kind(), Method: 'MapKeys' });
+        }
+        const keyType = this.Type().Key();
+        const keys = [];
+        for (const key of this._value.keys()) {
+            keys.push(new Value(key, keyType));
+        }
+        return $.arrayToSlice(keys);
     }
     Complex() {
-        // Placeholder for complex number support
-        return this._value;
+        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;
     }
     // Send sends a value to a channel
     Send(x) {
@@ -571,6 +769,23 @@ export class Value {
             this._parentStruct[this._fieldName] = x;
         }
     }
+    // SetComplex sets v's underlying value to x
+    SetComplex(x) {
+        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
     SetBytes(x) {
         if (!this.CanSet()) {
@@ -720,17 +935,22 @@ export class BasicType {
     _kind;
     _name;
     _size;
-    constructor(_kind, _name, _size = 8) {
+    _typeName;
+    constructor(_kind, _name, _size = 8, _typeName = '') {
         this._kind = _kind;
         this._name = _name;
         this._size = _size;
+        this._typeName = _typeName;
     }
     String() {
-        return this._name;
+        return this._typeName || this._name;
     }
     Kind() {
         return this._kind;
     }
+    Comparable() {
+        return this._kind !== Func && this._kind !== Map && this._kind !== Slice;
+    }
     Size() {
         return this._size;
     }
@@ -741,15 +961,34 @@ export class BasicType {
         return 0;
     }
     PkgPath() {
+        if (this._typeName) {
+            const dotIndex = this._typeName.lastIndexOf('.');
+            if (dotIndex > 0) {
+                return this._typeName.substring(0, dotIndex);
+            }
+        }
         return '';
     }
     Name() {
+        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;
     }
     Field(_i) {
         throw new Error(`reflect: Field of non-struct type ${this._name}`);
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Key() {
         throw new Error(`reflect: Key of non-map type ${this._name}`);
     }
@@ -762,6 +1001,9 @@ export class BasicType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this._kind);
     }
@@ -818,6 +1060,14 @@ export class BasicType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
+    Len() {
+        throw new Error('reflect: call of reflect.Type.Len on ' +
+            Kind_String(this._kind) +
+            ' Type');
+    }
     Bits() {
         const k = this._kind;
         switch (k) {
@@ -837,6 +1087,10 @@ export class BasicType {
             case Uint64:
             case Float64:
                 return 64;
+            case Complex64:
+                return 64;
+            case Complex128:
+                return 128;
             case Int:
             case Uint:
             case Uintptr:
@@ -858,6 +1112,9 @@ class SliceType {
     Kind() {
         return Slice;
     }
+    Comparable() {
+        return false;
+    }
     Size() {
         return 24; // slice header size
     }
@@ -877,6 +1134,12 @@ class SliceType {
     Field(_i) {
         throw new Error('reflect: Field of non-struct type');
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Key() {
         throw new Error('reflect: Key of non-map type');
     }
@@ -889,6 +1152,9 @@ class SliceType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     OverflowInt(_x) {
         throw new Error('reflect: call of reflect.Type.OverflowInt on slice Type');
     }
@@ -901,6 +1167,12 @@ class SliceType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
+    Len() {
+        throw new Error('reflect: call of reflect.Type.Len on slice Type');
+    }
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on slice Type');
     }
@@ -919,6 +1191,9 @@ class ArrayType {
     Kind() {
         return Array;
     }
+    Comparable() {
+        return this._elemType.Comparable();
+    }
     Size() {
         return this._elemType.Size() * this._len;
     }
@@ -941,6 +1216,12 @@ class ArrayType {
     Field(_i) {
         throw new Error('reflect: Field of non-struct type');
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Key() {
         throw new Error('reflect: Key of non-map type');
     }
@@ -953,6 +1234,9 @@ class ArrayType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -968,6 +1252,9 @@ class ArrayType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on array Type');
     }
@@ -984,6 +1271,9 @@ class PointerType {
     Kind() {
         return Ptr;
     }
+    Comparable() {
+        return true;
+    }
     Size() {
         return 8; // pointer size
     }
@@ -1003,6 +1293,12 @@ class PointerType {
     Field(_i) {
         throw new Error('reflect: Field of non-struct type');
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Key() {
         throw new Error('reflect: Key of non-map type');
     }
@@ -1017,6 +1313,9 @@ class PointerType {
         const elemTypeName = this._elemType.String();
         return typeImplementsInterface(elemTypeName, u);
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1032,6 +1331,12 @@ class PointerType {
     NumMethod() {
         return 0;
     }
+    MethodByName(name) {
+        return typeMethodByName(this._elemType, name);
+    }
+    Len() {
+        throw new Error('reflect: call of reflect.Type.Len on pointer Type');
+    }
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on pointer Type');
     }
@@ -1048,6 +1353,9 @@ class FunctionType {
     Kind() {
         return Func;
     }
+    Comparable() {
+        return false;
+    }
     Size() {
         return 8; // function pointer size
     }
@@ -1067,6 +1375,12 @@ class FunctionType {
     Field(_i) {
         throw new Error('reflect: Field of non-struct type');
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Key() {
         throw new Error('reflect: Key of non-map type');
     }
@@ -1079,6 +1393,9 @@ class FunctionType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1094,6 +1411,12 @@ class FunctionType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
+    Len() {
+        throw new Error('reflect: call of reflect.Type.Len on func Type');
+    }
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on func Type');
     }
@@ -1112,6 +1435,9 @@ class MapType {
     Kind() {
         return Map;
     }
+    Comparable() {
+        return false;
+    }
     Size() {
         return 8; // map header size
     }
@@ -1134,6 +1460,12 @@ class MapType {
     Field(_i) {
         throw new Error('reflect: Field of non-struct type');
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Implements(u) {
         if (!u) {
             return false;
@@ -1143,6 +1475,9 @@ class MapType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1158,6 +1493,12 @@ class MapType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
+    Len() {
+        throw new Error('reflect: call of reflect.Type.Len on map Type');
+    }
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on map Type');
     }
@@ -1205,6 +1546,61 @@ function typeImplementsInterface(typeName, interfaceType) {
     }
     return true;
 }
+function typeFieldByName(t, name) {
+    return typeFieldByNameFunc(t, (fieldName) => fieldName === name);
+}
+function typeFieldByNameFunc(t, match) {
+    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() {
+    return {
+        Name: '',
+        Type: new BasicType(Invalid, '<invalid>'),
+        Func: () => undefined,
+        Index: 0,
+    };
+}
+function methodFromSignature(signature, index) {
+    return {
+        Name: signature.name,
+        Type: new FunctionType('func'),
+        Func: () => undefined,
+        Index: index,
+    };
+}
+function typeMethods(t) {
+    const typeInfo = builtinGetTypeByName(t.String());
+    if (!typeInfo) {
+        return [];
+    }
+    if (isStructTypeInfo(typeInfo) || isInterfaceTypeInfo(typeInfo)) {
+        return typeInfo.methods || [];
+    }
+    return [];
+}
+function typeMethodByName(t, name) {
+    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, u) {
+    if (u === null) {
+        return false;
+    }
+    return t.String() === u.String() || t.Implements(u);
+}
 class StructType {
     _name;
     _fields;
@@ -1218,6 +1614,9 @@ class StructType {
     Kind() {
         return Struct;
     }
+    Comparable() {
+        return this._fields.every((field) => field.type.Comparable());
+    }
     Size() {
         // Struct size is implementation-defined, we'll use a reasonable default
         return this._fields.reduce((sum, field) => sum + field.type.Size(), 0);
@@ -1251,10 +1650,18 @@ class StructType {
         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],
         });
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Key() {
         throw new Error('reflect: Key of non-map type');
     }
@@ -1267,6 +1674,9 @@ class StructType {
         }
         return typeImplementsInterface(this._name, u);
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1280,7 +1690,13 @@ class StructType {
         throw new Error('reflect: call of reflect.Type.OverflowFloat on struct Type');
     }
     NumMethod() {
-        return 0;
+        return typeMethods(this).length;
+    }
+    MethodByName(name) {
+        return typeMethodByName(this, name);
+    }
+    Len() {
+        throw new Error('reflect: call of reflect.Type.Len on struct Type');
     }
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on struct Type');
@@ -1300,6 +1716,10 @@ class StructType {
                     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':
@@ -1311,24 +1731,29 @@ class StructType {
         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) {
@@ -1343,7 +1768,7 @@ class StructType {
                 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);
             }
@@ -1351,6 +1776,21 @@ class StructType {
         return new BasicType(Invalid, 'unknown', 8);
     }
 }
+function structFieldsFromTypeInfo(ti) {
+    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 {
     _elemType;
     _dir;
@@ -1374,6 +1814,9 @@ class ChannelType {
     Kind() {
         return Chan;
     }
+    Comparable() {
+        return true;
+    }
     Size() {
         // Channels are represented as pointers, so pointer size
         return 8;
@@ -1394,6 +1837,12 @@ class ChannelType {
     Field(_i) {
         throw new Error('reflect: Field of non-struct type');
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Key() {
         throw new Error('reflect: Key of non-map type');
     }
@@ -1406,6 +1855,9 @@ class ChannelType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1424,6 +1876,12 @@ class ChannelType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
+    Len() {
+        throw new Error('reflect: call of reflect.Type.Len on chan Type');
+    }
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on chan Type');
     }
@@ -1442,6 +1900,9 @@ class InterfaceType {
     Kind() {
         return Interface;
     }
+    Comparable() {
+        return true;
+    }
     Size() {
         return 16;
     }
@@ -1452,8 +1913,7 @@ class InterfaceType {
         return 0;
     }
     PkgPath() {
-        if (this._name === 'interface{}' ||
-            this._name.startsWith('interface {')) {
+        if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
             return '';
         }
         const dotIndex = this._name.lastIndexOf('.');
@@ -1463,8 +1923,7 @@ class InterfaceType {
         return '';
     }
     Name() {
-        if (this._name === 'interface{}' ||
-            this._name.startsWith('interface {')) {
+        if (this._name === 'interface{}' || this._name.startsWith('interface {')) {
             return this._name;
         }
         const dotIndex = this._name.lastIndexOf('.');
@@ -1476,12 +1935,21 @@ class InterfaceType {
     Field(_i) {
         throw new Error('reflect: Field of non-struct type');
     }
+    FieldByName(name) {
+        return typeFieldByName(this, name);
+    }
+    FieldByNameFunc(match) {
+        return typeFieldByNameFunc(this, match);
+    }
     Key() {
         throw new Error('reflect: Key of non-map type');
     }
     Implements(_u) {
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1495,7 +1963,13 @@ class InterfaceType {
         throw new Error('reflect: call of reflect.Type.OverflowFloat on interface Type');
     }
     NumMethod() {
-        return 0;
+        return typeMethods(this).length;
+    }
+    MethodByName(name) {
+        return typeMethodByName(this, name);
+    }
+    Len() {
+        throw new Error('reflect: call of reflect.Type.Len on interface Type');
     }
     Bits() {
         throw new Error('reflect: call of reflect.Type.Bits on interface Type');
@@ -1595,6 +2069,12 @@ function getTypeOf(value) {
                 const elemType = getTypeOf(value.value);
                 return new PointerType(elemType);
             }
+            if ('real' in value &&
+                'imag' in value &&
+                typeof value.real === 'number' &&
+                typeof value.imag === 'number') {
+                return new BasicType(Complex128, 'complex128', 16);
+            }
             // Check for arrays
             if (globalThis.Array.isArray(value)) {
                 if (value.length === 0) {
@@ -1672,7 +2152,7 @@ function getTypeOf(value) {
                             // 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,
                                 };
@@ -1701,70 +2181,83 @@ function getTypeOf(value) {
 }
 // Exported functions as required by godoc.txt
 export function TypeOf(i) {
-    return getTypeOf(i);
+    return internType(getTypeOf(i));
 }
 export function ValueOf(i) {
     return new Value(i, getTypeOf(i));
 }
+export function TypeAssert(typeArgs, v) {
+    const descriptor = typeArgs?.T;
+    if (!descriptor?.type) {
+        return [v.Interface(), true];
+    }
+    return $.typeAssertTuple(v.Interface(), descriptor.type);
+}
 export function ArrayOf(length, elem) {
-    return new ArrayType(elem, length);
+    return internType(new ArrayType(elem, length));
 }
 export function SliceOf(t) {
-    return new SliceType(t);
+    return internType(new SliceType(t));
 }
 export function PointerTo(t) {
     if (t === null)
         return null;
-    return new PointerType(t);
+    return internType(new PointerType(t));
 }
 export function PtrTo(t) {
     return PointerTo(t); // PtrTo is an alias for PointerTo
 }
 export function MapOf(key, elem) {
-    return new MapType(key, elem);
+    return internType(new MapType(key, elem));
 }
 export function ChanOf(dir, t) {
-    return new ChannelType(t, dir);
+    return internType(new ChannelType(t, dir));
 }
 export function TypeFor(typeArgs) {
     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) {
     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));
     }
 }
 function functionTypeFromInfo(info) {