goscript 0.0.60 → 0.0.62

package/dist/gs/reflect/type.js

@@ -1,3 +1,8 @@
+import { StructField, StructTag, ValueError } from './types.js';
+export { StructField };
+import { getTypeByName as builtinGetTypeByName, TypeKind, isStructTypeInfo, isInterfaceTypeInfo, isStructFieldInfo, } from '../builtin/type.js';
+import { Zero } from './value.js';
+import { DeepEqual } from './deepequal.js';
 // rtype is the common implementation of most values
 export class rtype {
     kind;
@@ -143,13 +148,73 @@ export const Slice = 23;
 export const String = 24;
 export const Struct = 25;
 export const UnsafePointer = 26;
+// InvalidTypeInstance is a singleton type for invalid/zero reflect.Value
+class InvalidTypeClass {
+    Kind() {
+        return Invalid;
+    }
+    String() {
+        return '<invalid reflect.Value>';
+    }
+    Name() {
+        return '';
+    }
+    Size() {
+        return 0;
+    }
+    Elem() {
+        throw new Error('reflect: Elem of invalid type');
+    }
+    Key() {
+        throw new Error('reflect: Key of invalid type');
+    }
+    NumField() {
+        return 0;
+    }
+    Field(_i) {
+        throw new Error('reflect: Field of invalid type');
+    }
+    Implements(_u) {
+        return false;
+    }
+    OverflowInt(_x) {
+        throw new Error('reflect: OverflowInt of invalid type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: OverflowUint of invalid type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: OverflowFloat of invalid type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        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 {
     _value;
     _type;
-    constructor(_value, _type) {
-        this._value = _value;
-        this._type = _type;
+    constructor(value, type) {
+        // 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;
+            this._type = type;
+        }
     }
     clone() {
         return new Value(this._value, this._type);
@@ -265,9 +330,19 @@ export class Value {
     NumField() {
         return this._type.NumField();
     }
-    Field(_i) {
-        // Simplified implementation for struct field access
-        return new Value(null, this._type);
+    Field(i) {
+        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[field.Name];
+        if (fieldVal === undefined) {
+            fieldVal = null;
+        }
+        return new Value(fieldVal, field.Type);
     }
     // Additional methods needed by various parts of the codebase
     UnsafePointer() {
@@ -288,7 +363,36 @@ export class Value {
         // Simple conversion - in a real implementation this would do type conversion
         return new Value(this._value, t);
     }
+    CanAddr() {
+        return this.Kind() !== Ptr && this._value !== null; // Simplified
+    }
+    Addr() {
+        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
+    }
+    CanSet() {
+        return this.IsValid() && this.Kind() !== Ptr; // Simplified
+    }
+    Set(x) {
+        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
+    Interface() {
+        return this._value;
+    }
+    IsZero() {
+        const zeroVal = Zero(this.Type()).value;
+        return DeepEqual(this._value, zeroVal);
+    }
     typ() {
         return new rtype(this._type.Kind());
     }
@@ -331,6 +435,207 @@ export class Value {
             channelObj._sendQueue.push(valueToSend);
         }
     }
+    // SetString sets v's underlying value to x
+    SetString(x) {
+        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
+    SetInt(x) {
+        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
+    SetUint(x) {
+        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
+    SetBool(x) {
+        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
+    SetFloat(x) {
+        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
+    SetBytes(x) {
+        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
+    SetZero() {
+        if (!this.CanSet()) {
+            throw new Error('reflect: call of reflect.Value.SetZero on unaddressable value');
+        }
+        const zeroVal = Zero(this.Type());
+        this._value = zeroVal.value;
+    }
+    // SetLen sets v's length to n
+    SetLen(n) {
+        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
+    SetMapIndex(key, elem) {
+        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;
+        const keyVal = key.value;
+        const elemVal = elem.value;
+        mapObj.set(keyVal, elemVal);
+    }
+    // Grow increases the slice's capacity, if necessary
+    Grow(n) {
+        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
+    Cap() {
+        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
+    NumMethod() {
+        return 0; // Simplified - methods not fully implemented
+    }
+    // Equal reports whether v is equal to u
+    Equal(u) {
+        return DeepEqual(this._value, u.value);
+    }
+    // CanInterface reports whether Interface can be used without panicking
+    CanInterface() {
+        return this.IsValid();
+    }
+    // OverflowInt reports whether the int64 x cannot be represented by v's type
+    OverflowInt(x) {
+        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
+    OverflowUint(x) {
+        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
+    OverflowFloat(x) {
+        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
 export class BasicType {
@@ -352,7 +657,7 @@ export class BasicType {
         return this._size;
     }
     Elem() {
-        return null;
+        throw new Error(`reflect: Elem of invalid type ${this._name}`);
     }
     NumField() {
         return 0;
@@ -360,12 +665,108 @@ export class BasicType {
     PkgPath() {
         return '';
     }
+    Name() {
+        // Basic types have names like 'int', 'string', etc.
+        return this._name;
+    }
     Field(_i) {
-        return null;
+        throw new Error(`reflect: Field of non-struct type ${this._name}`);
+    }
+    Key() {
+        throw new Error(`reflect: Key of non-map type ${this._name}`);
+    }
+    Implements(u) {
+        if (!u) {
+            return false;
+        }
+        if (u.Kind() !== Interface) {
+            throw new Error('reflect: non-interface type passed to Type.Implements');
+        }
+        return false;
     }
     common() {
         return new rtype(this._kind);
     }
+    OverflowInt(x) {
+        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');
+        }
+    }
+    OverflowUint(x) {
+        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');
+        }
+    }
+    OverflowFloat(x) {
+        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');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        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
 class SliceType {
@@ -391,6 +792,40 @@ class SliceType {
     PkgPath() {
         return '';
     }
+    Name() {
+        // Slice types are unnamed composite types
+        return '';
+    }
+    Field(_i) {
+        throw new Error('reflect: Field of non-struct type');
+    }
+    Key() {
+        throw new Error('reflect: Key of non-map type');
+    }
+    Implements(u) {
+        if (!u) {
+            return false;
+        }
+        if (u.Kind() !== Interface) {
+            throw new Error('reflect: non-interface type passed to Type.Implements');
+        }
+        return false;
+    }
+    OverflowInt(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowInt on slice Type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowUint on slice Type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowFloat on slice Type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        throw new Error('reflect: call of reflect.Type.Bits on slice Type');
+    }
 }
 // Array type implementation
 class ArrayType {
@@ -421,12 +856,43 @@ class ArrayType {
     PkgPath() {
         return '';
     }
+    Name() {
+        // Array types are unnamed composite types
+        return '';
+    }
     Field(_i) {
-        return null;
+        throw new Error('reflect: Field of non-struct type');
+    }
+    Key() {
+        throw new Error('reflect: Key of non-map type');
+    }
+    Implements(u) {
+        if (!u) {
+            return false;
+        }
+        if (u.Kind() !== Interface) {
+            throw new Error('reflect: non-interface type passed to Type.Implements');
+        }
+        return false;
     }
     common() {
         return new rtype(this.Kind());
     }
+    OverflowInt(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowInt on array Type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowUint on array Type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowFloat on array Type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        throw new Error('reflect: call of reflect.Type.Bits on array Type');
+    }
 }
 // Pointer type implementation
 class PointerType {
@@ -452,12 +918,45 @@ class PointerType {
     PkgPath() {
         return '';
     }
+    Name() {
+        // Pointer types are unnamed composite types
+        return '';
+    }
     Field(_i) {
-        return null;
+        throw new Error('reflect: Field of non-struct type');
+    }
+    Key() {
+        throw new Error('reflect: Key of non-map type');
+    }
+    Implements(u) {
+        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);
     }
     common() {
         return new rtype(this.Kind());
     }
+    OverflowInt(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowInt on pointer Type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowUint on pointer Type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowFloat on pointer Type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        throw new Error('reflect: call of reflect.Type.Bits on pointer Type');
+    }
 }
 // Function type implementation
 class FunctionType {
@@ -475,7 +974,7 @@ class FunctionType {
         return 8; // function pointer size
     }
     Elem() {
-        return null;
+        throw new Error('reflect: Elem of invalid type');
     }
     NumField() {
         return 0;
@@ -483,12 +982,43 @@ class FunctionType {
     PkgPath() {
         return '';
     }
+    Name() {
+        // Function types are unnamed composite types
+        return '';
+    }
     Field(_i) {
-        return null;
+        throw new Error('reflect: Field of non-struct type');
+    }
+    Key() {
+        throw new Error('reflect: Key of non-map type');
+    }
+    Implements(u) {
+        if (!u) {
+            return false;
+        }
+        if (u.Kind() !== Interface) {
+            throw new Error('reflect: non-interface type passed to Type.Implements');
+        }
+        return false;
     }
     common() {
         return new rtype(this.Kind());
     }
+    OverflowInt(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowInt on func Type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowUint on func Type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowFloat on func Type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        throw new Error('reflect: call of reflect.Type.Bits on func Type');
+    }
 }
 // Map type implementation
 class MapType {
@@ -519,14 +1049,82 @@ class MapType {
     PkgPath() {
         return '';
     }
+    Name() {
+        // Map types are unnamed composite types
+        return '';
+    }
     Field(_i) {
-        return null;
+        throw new Error('reflect: Field of non-struct type');
+    }
+    Implements(u) {
+        if (!u) {
+            return false;
+        }
+        if (u.Kind() !== Interface) {
+            throw new Error('reflect: non-interface type passed to Type.Implements');
+        }
+        return false;
     }
     common() {
         return new rtype(this.Kind());
     }
+    OverflowInt(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowInt on map Type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowUint on map Type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowFloat on map Type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        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, interfaceType) {
+    // 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 {
     _name;
     _fields;
@@ -545,21 +1143,133 @@ class StructType {
         return this._fields.reduce((sum, field) => sum + field.type.Size(), 0);
     }
     Elem() {
-        return null;
+        throw new Error('reflect: Elem of invalid type');
     }
     NumField() {
         return this._fields.length;
     }
     PkgPath() {
+        // 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 '';
     }
-    Field(_i) {
-        // Stub implementation
-        return null;
+    Name() {
+        // 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;
+    }
+    Field(i) {
+        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,
+        });
+    }
+    Key() {
+        throw new Error('reflect: Key of non-map type');
+    }
+    Implements(u) {
+        if (!u) {
+            return false;
+        }
+        if (u.Kind() !== Interface) {
+            throw new Error('reflect: non-interface type passed to Type.Implements');
+        }
+        return typeImplementsInterface(this._name, u);
     }
     common() {
         return new rtype(this.Kind());
     }
+    OverflowInt(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowInt on struct Type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowUint on struct Type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowFloat on struct Type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        throw new Error('reflect: call of reflect.Type.Bits on struct Type');
+    }
+    static createTypeFromFieldInfo(ti) {
+        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 {
     _elemType;
@@ -597,8 +1307,24 @@ class ChannelType {
     PkgPath() {
         return '';
     }
-    Field(_) {
-        return null;
+    Name() {
+        // Channel types are unnamed composite types
+        return '';
+    }
+    Field(_i) {
+        throw new Error('reflect: Field of non-struct type');
+    }
+    Key() {
+        throw new Error('reflect: Key of non-map type');
+    }
+    Implements(u) {
+        if (!u) {
+            return false;
+        }
+        if (u.Kind() !== Interface) {
+            throw new Error('reflect: non-interface type passed to Type.Implements');
+        }
+        return false;
     }
     common() {
         return new rtype(this.Kind());
@@ -606,8 +1332,93 @@ class ChannelType {
     ChanDir() {
         return this._dir;
     }
+    OverflowInt(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowInt on chan Type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowUint on chan Type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowFloat on chan Type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        throw new Error('reflect: call of reflect.Type.Bits on chan Type');
+    }
+}
+// Interface type implementation
+class InterfaceType {
+    _name;
+    constructor(_name = 'interface{}') {
+        this._name = _name;
+    }
+    String() {
+        return this._name;
+    }
+    Kind() {
+        return Interface;
+    }
+    Size() {
+        return 16;
+    }
+    Elem() {
+        throw new Error('reflect: Elem of invalid type');
+    }
+    NumField() {
+        return 0;
+    }
+    PkgPath() {
+        return '';
+    }
+    Name() {
+        return this._name;
+    }
+    Field(_i) {
+        throw new Error('reflect: Field of non-struct type');
+    }
+    Key() {
+        throw new Error('reflect: Key of non-map type');
+    }
+    Implements(_u) {
+        return false;
+    }
+    common() {
+        return new rtype(this.Kind());
+    }
+    OverflowInt(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowInt on interface Type');
+    }
+    OverflowUint(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowUint on interface Type');
+    }
+    OverflowFloat(_x) {
+        throw new Error('reflect: call of reflect.Type.OverflowFloat on interface Type');
+    }
+    NumMethod() {
+        return 0;
+    }
+    Bits() {
+        throw new Error('reflect: call of reflect.Type.Bits on interface Type');
+    }
 }
 function getTypeOf(value) {
+    // 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.__isTypedNil) {
+        const typeName = value.__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);
     }
@@ -757,20 +1568,38 @@ function getTypeOf(value) {
                 '__typeInfo' in value.constructor) {
                 const typeInfo = value.constructor.__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 = [];
+                    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.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);
@@ -790,6 +1619,8 @@ export function SliceOf(t) {
     return new SliceType(t);
 }
 export function PointerTo(t) {
+    if (t === null)
+        return null;
     return new PointerType(t);
 }
 export function PtrTo(t) {
@@ -801,6 +1632,41 @@ export function MapOf(key, elem) {
 export function ChanOf(dir, t) {
     return new ChannelType(t, dir);
 }
+export function TypeFor() {
+    return new InterfaceType('interface{}');
+}
+/**
+ * getInterfaceTypeByName looks up a registered interface type by name
+ * and returns a Type for it. Returns an interface{} type if not found.
+ */
+export function getInterfaceTypeByName(name) {
+    const typeInfo = builtinGetTypeByName(name);
+    if (typeInfo && typeInfo.kind === TypeKind.Interface) {
+        // InterfaceTypeInfo
+        const methods = typeInfo.methods || [];
+        if (methods.length > 0) {
+            // Build interface signature with methods
+            const methodSigs = methods
+                .map((m) => {
+                const args = m.args
+                    ?.map((a) => (typeof a === 'string' ? a : 'any'))
+                    .join(', ') || '';
+                const returns = m.returns?.map((r) => typeof r === 'string' ? r : 'any');
+                let returnSig = '';
+                if (returns && returns.length === 1) {
+                    returnSig = ` ${returns[0]}`;
+                }
+                else if (returns && returns.length > 1) {
+                    returnSig = ` (${returns.join(', ')})`;
+                }
+                return `${m.name}(${args})${returnSig}`;
+            })
+                .join('; ');
+            return new InterfaceType(`interface { ${methodSigs} }`);
+        }
+    }
+    return new InterfaceType('interface{}');
+}
 // Additional functions from merged files
 export function canRangeFunc(t) {
     const kind = t.Kind();