goscript 0.1.1 → 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';
@@ -153,6 +154,7 @@ 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) {
@@ -162,17 +164,32 @@ function pointerAddress(value) {
     }
     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;
     }
@@ -188,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');
     }
@@ -203,6 +229,9 @@ class InvalidTypeClass {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
     Len() {
         throw new Error('reflect: Len of invalid type');
     }
@@ -344,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;
@@ -381,6 +431,20 @@ 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;
@@ -422,6 +486,15 @@ export class 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;
     }
@@ -445,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
@@ -489,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);
@@ -500,12 +606,29 @@ 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) {
@@ -812,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;
     }
@@ -833,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}`);
     }
@@ -854,6 +1001,9 @@ export class BasicType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this._kind);
     }
@@ -910,6 +1060,9 @@ 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) +
@@ -959,6 +1112,9 @@ class SliceType {
     Kind() {
         return Slice;
     }
+    Comparable() {
+        return false;
+    }
     Size() {
         return 24; // slice header size
     }
@@ -978,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');
     }
@@ -990,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');
     }
@@ -1002,6 +1167,9 @@ class SliceType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
     Len() {
         throw new Error('reflect: call of reflect.Type.Len on slice Type');
     }
@@ -1023,6 +1191,9 @@ class ArrayType {
     Kind() {
         return Array;
     }
+    Comparable() {
+        return this._elemType.Comparable();
+    }
     Size() {
         return this._elemType.Size() * this._len;
     }
@@ -1045,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');
     }
@@ -1057,6 +1234,9 @@ class ArrayType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1072,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');
     }
@@ -1088,6 +1271,9 @@ class PointerType {
     Kind() {
         return Ptr;
     }
+    Comparable() {
+        return true;
+    }
     Size() {
         return 8; // pointer size
     }
@@ -1107,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');
     }
@@ -1121,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());
     }
@@ -1136,6 +1331,9 @@ 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');
     }
@@ -1155,6 +1353,9 @@ class FunctionType {
     Kind() {
         return Func;
     }
+    Comparable() {
+        return false;
+    }
     Size() {
         return 8; // function pointer size
     }
@@ -1174,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');
     }
@@ -1186,6 +1393,9 @@ class FunctionType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1201,6 +1411,9 @@ class FunctionType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
     Len() {
         throw new Error('reflect: call of reflect.Type.Len on func Type');
     }
@@ -1222,6 +1435,9 @@ class MapType {
     Kind() {
         return Map;
     }
+    Comparable() {
+        return false;
+    }
     Size() {
         return 8; // map header size
     }
@@ -1244,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;
@@ -1253,6 +1475,9 @@ class MapType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1268,6 +1493,9 @@ class MapType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
     Len() {
         throw new Error('reflect: call of reflect.Type.Len on map Type');
     }
@@ -1318,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;
@@ -1331,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);
@@ -1364,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');
     }
@@ -1380,6 +1674,9 @@ class StructType {
         }
         return typeImplementsInterface(this._name, u);
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1393,7 +1690,10 @@ 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');
@@ -1431,28 +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);
+                            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) {
@@ -1467,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);
             }
@@ -1475,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;
@@ -1498,6 +1814,9 @@ class ChannelType {
     Kind() {
         return Chan;
     }
+    Comparable() {
+        return true;
+    }
     Size() {
         // Channels are represented as pointers, so pointer size
         return 8;
@@ -1518,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');
     }
@@ -1530,6 +1855,9 @@ class ChannelType {
         }
         return false;
     }
+    AssignableTo(u) {
+        return typeAssignableTo(this, u);
+    }
     common() {
         return new rtype(this.Kind());
     }
@@ -1548,6 +1876,9 @@ class ChannelType {
     NumMethod() {
         return 0;
     }
+    MethodByName(_name) {
+        return [zeroMethod(), false];
+    }
     Len() {
         throw new Error('reflect: call of reflect.Type.Len on chan Type');
     }
@@ -1569,6 +1900,9 @@ class InterfaceType {
     Kind() {
         return Interface;
     }
+    Comparable() {
+        return true;
+    }
     Size() {
         return 16;
     }
@@ -1601,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());
     }
@@ -1620,7 +1963,10 @@ 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');
@@ -1835,7 +2181,7 @@ 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));
@@ -1848,64 +2194,70 @@ export function TypeAssert(typeArgs, v) {
     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) {