goscript 0.1.3 → 0.2.0

package/gs/builtin/type.ts

@@ -45,8 +45,14 @@ export interface MethodSignature {
  */
 export interface StructFieldInfo {
   type: TypeInfo | string // The field's type
-  name?: string // The Go field name when it differs from the TypeScript key.
+  name: string // The Go field name.
+  key?: string // The runtime storage key on generated or dynamic values.
   tag?: string // The struct field tag (e.g., `json:"name,omitempty"`)
+  pkgPath?: string // Non-empty for unexported fields.
+  anonymous?: boolean
+  index?: number[]
+  offset?: number
+  exported?: boolean
 }
 
 /**
@@ -56,7 +62,7 @@ export interface StructTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Struct
   methods: MethodSignature[] // Array of method signatures
   ctor?: new (...args: any[]) => any
-  fields: Record<string, TypeInfo | string | StructFieldInfo> // Field names and types for struct fields
+  fields: StructFieldInfo[] // Ordered field descriptors.
 }
 
 /**
@@ -185,12 +191,13 @@ export function isChannelTypeInfo(info: TypeInfo): info is ChannelTypeInfo {
  * vs a direct TypeInfo or string
  */
 export function isStructFieldInfo(
-  fieldValue: TypeInfo | string | StructFieldInfo,
+  fieldValue: unknown,
 ): fieldValue is StructFieldInfo {
   return (
     typeof fieldValue === 'object' &&
     fieldValue !== null &&
     'type' in fieldValue &&
+    'name' in fieldValue &&
     !('kind' in fieldValue)
   )
 }
@@ -234,7 +241,7 @@ export const registerStructType = (
   zeroValue: any,
   methods: MethodSignature[],
   ctor: new (...args: any[]) => any,
-  fields: Record<string, TypeInfo | string | StructFieldInfo> = {},
+  fields: StructFieldInfo[] = [],
 ): StructTypeInfo => {
   const typeInfo: StructTypeInfo = {
     name,
@@ -320,29 +327,69 @@ function typeInfoRuntimeName(info: TypeInfo): string | undefined {
 }
 
 function goTypeMatchesTypeInfo(goType: string, info: TypeInfo): boolean {
-  return goType === typeInfoRuntimeName(info)
+  const runtimeName = typeInfoRuntimeName(info)
+  return (
+    (runtimeName !== undefined && goType === runtimeName) ||
+    compareTypeStringWithTypeInfo(goType, info)
+  )
+}
+
+interface TypeInfoComparisonState {
+  seenPairs: Set<string>
+  objectIDs: WeakMap<object, number>
+  nextObjectID: number
+}
+
+function newTypeInfoComparisonState(): TypeInfoComparisonState {
+  return {
+    seenPairs: new Set(),
+    objectIDs: new WeakMap(),
+    nextObjectID: 0,
+  }
+}
+
+function typeInfoComparisonID(
+  raw: string | TypeInfo,
+  normalized: TypeInfo,
+  state: TypeInfoComparisonState,
+): string {
+  const runtimeName = typeInfoRuntimeName(normalized)
+  if (runtimeName !== undefined) {
+    return `${normalized.kind}:${runtimeName}`
+  }
+  if (typeof raw === 'string') {
+    return `string:${raw}`
+  }
+  const existing = state.objectIDs.get(raw)
+  if (existing !== undefined) {
+    return `object:${existing}`
+  }
+  const id = state.nextObjectID
+  state.nextObjectID += 1
+  state.objectIDs.set(raw, id)
+  return `object:${id}`
 }
 
 function compareOptionalTypeInfo(
-  type1?: string | TypeInfo,
-  type2?: string | TypeInfo,
+  type1: string | TypeInfo | undefined,
+  type2: string | TypeInfo | undefined,
+  state: TypeInfoComparisonState,
 ): boolean {
   if (type1 === undefined && type2 === undefined) return true
   if (type1 === undefined || type2 === undefined) return false
-  // Assuming areTypeInfosIdentical will handle normalization if needed,
-  // but type1 and type2 here are expected to be direct fields from TypeInfo objects.
-  return areTypeInfosIdentical(type1, type2)
+  return areTypeInfosIdenticalWithSeen(type1, type2, state)
 }
 
 function areFuncParamOrResultArraysIdentical(
   arr1?: (string | TypeInfo)[],
   arr2?: (string | TypeInfo)[],
+  state = newTypeInfoComparisonState(),
 ): boolean {
   if (arr1 === undefined && arr2 === undefined) return true
   if (arr1 === undefined || arr2 === undefined) return false
   if (arr1.length !== arr2.length) return false
-  for (let i = 0; i < arr1.length; i++) {
-    if (!areTypeInfosIdentical(arr1[i], arr2[i])) {
+  for (const [index, typeInfo] of arr1.entries()) {
+    if (!areTypeInfosIdenticalWithSeen(typeInfo, arr2[index], state)) {
       return false
     }
   }
@@ -352,58 +399,75 @@ function areFuncParamOrResultArraysIdentical(
 function areFuncSignaturesIdentical(
   func1: FunctionTypeInfo,
   func2: FunctionTypeInfo,
+  state = newTypeInfoComparisonState(),
 ): boolean {
   if ((func1.isVariadic || false) !== (func2.isVariadic || false)) {
     return false
   }
   return (
-    areFuncParamOrResultArraysIdentical(func1.params, func2.params) &&
-    areFuncParamOrResultArraysIdentical(func1.results, func2.results)
+    areFuncParamOrResultArraysIdentical(func1.params, func2.params, state) &&
+    areFuncParamOrResultArraysIdentical(func1.results, func2.results, state)
   )
 }
 
 export function areTypeInfosIdentical(
   type1InfoOrName: string | TypeInfo,
   type2InfoOrName: string | TypeInfo,
+): boolean {
+  return areTypeInfosIdenticalWithSeen(
+    type1InfoOrName,
+    type2InfoOrName,
+    newTypeInfoComparisonState(),
+  )
+}
+
+function areTypeInfosIdenticalWithSeen(
+  type1InfoOrName: string | TypeInfo,
+  type2InfoOrName: string | TypeInfo,
+  state: TypeInfoComparisonState,
 ): boolean {
   const t1Norm = normalizeTypeInfo(type1InfoOrName)
   const t2Norm = normalizeTypeInfo(type2InfoOrName)
 
-  if (t1Norm === t2Norm) return true // Object identity
+  if (t1Norm === t2Norm) return true
   if (t1Norm.kind !== t2Norm.kind) return false
 
-  // If types have names, the names must match for identity.
-  // If one has a name and the other doesn't, they are not identical.
+  if ((t1Norm.typeName ?? '') !== (t2Norm.typeName ?? '')) return false
   if (t1Norm.name !== t2Norm.name) return false
 
-  // If both are named and names match, for Basic, Struct, Interface, this is sufficient for identity.
   if (
-    t1Norm.name !== undefined /* && t2Norm.name is also defined and equal */
-  ) {
-    if (
-      t1Norm.kind === TypeKind.Basic ||
+    t1Norm.name !== undefined &&
+    (t1Norm.kind === TypeKind.Basic ||
       t1Norm.kind === TypeKind.Struct ||
-      t1Norm.kind === TypeKind.Interface
-    ) {
-      return true
-    }
+      t1Norm.kind === TypeKind.Interface)
+  ) {
+    return true
+  }
+
+  const pairKey = `${typeInfoComparisonID(
+    type1InfoOrName,
+    t1Norm,
+    state,
+  )}|${typeInfoComparisonID(type2InfoOrName, t2Norm, state)}`
+  if (state.seenPairs.has(pairKey)) {
+    return true
   }
-  // For other types (Pointer, Slice, etc.), or if both are anonymous (name is undefined),
-  // structural comparison is needed.
+  state.seenPairs.add(pairKey)
 
   switch (t1Norm.kind) {
     case TypeKind.Basic:
-      // Names matched if they were defined, or both undefined (which means true by t1Norm.name !== t2Norm.name being false)
       return true
     case TypeKind.Pointer:
       return compareOptionalTypeInfo(
         (t1Norm as PointerTypeInfo).elemType,
         (t2Norm as PointerTypeInfo).elemType,
+        state,
       )
     case TypeKind.Slice:
       return compareOptionalTypeInfo(
         (t1Norm as SliceTypeInfo).elemType,
         (t2Norm as SliceTypeInfo).elemType,
+        state,
       )
     case TypeKind.Array:
       return (
@@ -411,6 +475,7 @@ export function areTypeInfosIdentical(
         compareOptionalTypeInfo(
           (t1Norm as ArrayTypeInfo).elemType,
           (t2Norm as ArrayTypeInfo).elemType,
+          state,
         )
       )
     case TypeKind.Map:
@@ -418,39 +483,119 @@ export function areTypeInfosIdentical(
         compareOptionalTypeInfo(
           (t1Norm as MapTypeInfo).keyType,
           (t2Norm as MapTypeInfo).keyType,
+          state,
         ) &&
         compareOptionalTypeInfo(
           (t1Norm as MapTypeInfo).elemType,
           (t2Norm as MapTypeInfo).elemType,
+          state,
         )
       )
     case TypeKind.Channel:
       return (
-        // Ensure direction property exists before comparing, or handle undefined if it can be
         ((t1Norm as ChannelTypeInfo).direction || 'both') ===
           ((t2Norm as ChannelTypeInfo).direction || 'both') &&
         compareOptionalTypeInfo(
           (t1Norm as ChannelTypeInfo).elemType,
           (t2Norm as ChannelTypeInfo).elemType,
+          state,
         )
       )
     case TypeKind.Function:
       return areFuncSignaturesIdentical(
         t1Norm as FunctionTypeInfo,
         t2Norm as FunctionTypeInfo,
+        state,
       )
     case TypeKind.Struct:
+      if (t2Norm.kind !== TypeKind.Struct) {
+        return false
+      }
+      return areStructTypeInfosIdentical(t1Norm, t2Norm, state)
     case TypeKind.Interface:
-      // If we reach here, names were undefined (both anonymous) or names matched but was not Basic/Struct/Interface.
-      // For anonymous Struct/Interface, strict identity means full structural comparison.
-      // For now, we consider anonymous types not identical unless they are the same object (caught above).
-      // If they were named and matched, 'return true' was hit earlier for these kinds.
-      return false
+      if (t2Norm.kind !== TypeKind.Interface) {
+        return false
+      }
+      return areInterfaceTypeInfosIdentical(t1Norm, t2Norm, state)
     default:
       return false
   }
 }
 
+function areStructTypeInfosIdentical(
+  struct1: StructTypeInfo,
+  struct2: StructTypeInfo,
+  state: TypeInfoComparisonState,
+): boolean {
+  if (struct1.fields.length !== struct2.fields.length) {
+    return false
+  }
+  for (const [index, field1] of struct1.fields.entries()) {
+    const field2 = struct2.fields[index]
+    if (
+      field2 === undefined ||
+      field1.name !== field2.name ||
+      (field1.pkgPath ?? '') !== (field2.pkgPath ?? '') ||
+      (field1.tag ?? '') !== (field2.tag ?? '') ||
+      (field1.anonymous ?? false) !== (field2.anonymous ?? false) ||
+      !areTypeInfosIdenticalWithSeen(field1.type, field2.type, state)
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+function areInterfaceTypeInfosIdentical(
+  interface1: InterfaceTypeInfo,
+  interface2: InterfaceTypeInfo,
+  state: TypeInfoComparisonState,
+): boolean {
+  const methods1 = sortedMethodSignatures(interface1.methods)
+  const methods2 = sortedMethodSignatures(interface2.methods)
+  if (methods1.length !== methods2.length) {
+    return false
+  }
+  for (const [index, method1] of methods1.entries()) {
+    const method2 = methods2[index]
+    if (
+      method2 === undefined ||
+      method1.name !== method2.name ||
+      !areMethodArgArraysIdentical(method1.args, method2.args, state) ||
+      !areMethodArgArraysIdentical(method1.returns, method2.returns, state)
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+function sortedMethodSignatures(
+  methods: MethodSignature[] = [],
+): MethodSignature[] {
+  return [...methods].sort((left, right) => left.name.localeCompare(right.name))
+}
+
+function areMethodArgArraysIdentical(
+  args1: MethodArg[],
+  args2: MethodArg[],
+  state: TypeInfoComparisonState,
+): boolean {
+  if (args1.length !== args2.length) {
+    return false
+  }
+  for (const [index, arg1] of args1.entries()) {
+    const arg2 = args2[index]
+    if (
+      arg2 === undefined ||
+      !areTypeInfosIdenticalWithSeen(arg1.type, arg2.type, state)
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
 /**
  * Validates that a map key matches the expected type info.
  *
@@ -487,7 +632,23 @@ function validateMapKey(key: any, keyTypeInfo: TypeInfo): boolean {
  */
 function matchesBasicType(value: any, info: TypeInfo): boolean {
   if (info.name === 'string') return typeof value === 'string'
-  if (info.name === 'number' || info.name === 'int' || info.name === 'float64')
+  if (
+    info.name === 'number' ||
+    info.name === 'int' ||
+    info.name === 'int8' ||
+    info.name === 'int16' ||
+    info.name === 'int32' ||
+    info.name === 'int64' ||
+    info.name === 'uint' ||
+    info.name === 'uint8' ||
+    info.name === 'byte' ||
+    info.name === 'uint16' ||
+    info.name === 'uint32' ||
+    info.name === 'uint64' ||
+    info.name === 'uintptr' ||
+    info.name === 'float32' ||
+    info.name === 'float64'
+  )
     return typeof value === 'number'
   if (info.name === 'boolean' || info.name === 'bool')
     return typeof value === 'boolean'
@@ -519,7 +680,8 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
 
   // For anonymous struct types (no constructor), use structural matching
   if (typeof value === 'object' && value !== null && info.fields) {
-    const fieldNames = Object.keys(info.fields || {})
+    const fields = info.fields || []
+    const fieldNames = fields.map((field) => structFieldRuntimeKey(field))
     const valueFields = Object.keys(value)
 
     const fieldsExist = fieldNames.every((field) => field in value)
@@ -529,10 +691,9 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
     )
 
     if (fieldsExist && sameFieldCount && allFieldsInStruct) {
-      return Object.entries(info.fields).every(([fieldName, fieldType]) => {
-        const fieldTypeInfo =
-          isStructFieldInfo(fieldType) ? fieldType.type : fieldType
-        return matchesType(value[fieldName], normalizeTypeInfo(fieldTypeInfo))
+      return fields.every((field) => {
+        const key = structFieldRuntimeKey(field)
+        return matchesType(value[key], normalizeTypeInfo(field.type))
       })
     }
 
@@ -542,6 +703,10 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
   return false
 }
 
+export function structFieldRuntimeKey(field: StructFieldInfo): string {
+  return field.key || field.name
+}
+
 /**
  * Checks if a value matches an interface type info by verifying it implements
  * all required methods with compatible signatures.
@@ -859,17 +1024,30 @@ function matchesPointerType(value: any, info: TypeInfo): boolean {
  * @returns True if the value matches the function type, false otherwise.
  */
 function matchesFunctionType(value: any, info: FunctionTypeInfo): boolean {
-  // First check if the value is a function
   if (typeof value !== 'function') {
     return false
   }
-
-  // This is important for named function types
-  if (info.name && value.__goTypeName) {
-    return info.name === value.__goTypeName
+  const valueInfo = functionValueTypeInfo(value)
+  if (!valueInfo) {
+    return false
   }
+  return areTypeInfosIdentical(valueInfo, info)
+}
 
-  return true
+function functionValueTypeInfo(value: any): FunctionTypeInfo | null {
+  const typeInfo = value.__typeInfo
+  if (!typeInfo || typeInfo.kind !== TypeKind.Function) {
+    return null
+  }
+  const goTypeName =
+    typeof value.__goTypeName === 'string' ? value.__goTypeName : undefined
+  if (goTypeName && typeInfo.name && goTypeName !== typeInfo.name) {
+    return null
+  }
+  if (goTypeName && !typeInfo.name) {
+    return { ...typeInfo, name: goTypeName }
+  }
+  return typeInfo
 }
 
 /**
@@ -994,15 +1172,21 @@ function matchesType(value: any, info: TypeInfo): boolean {
  */
 function compareTypeStringWithTypeInfo(
   typeStr: string,
-  typeInfo: TypeInfo,
+  typeInfo: string | TypeInfo,
 ): boolean {
+  const normalized = normalizeTypeInfo(typeInfo)
+  const runtimeName = typeInfoRuntimeName(normalized)
+  if (runtimeName !== undefined && typeStr === runtimeName) {
+    return true
+  }
+
   // For pointer types, strip the leading * and compare element types
-  if (isPointerTypeInfo(typeInfo)) {
+  if (isPointerTypeInfo(normalized)) {
     if (!typeStr.startsWith('*')) {
       return false
     }
     const elemStr = typeStr.slice(1)
-    const elemType = typeInfo.elemType
+    const elemType = normalized.elemType
     if (!elemType) {
       return false
     }
@@ -1036,8 +1220,8 @@ function compareTypeStringWithTypeInfo(
       }
 
       // Compare fields
-      const typeInfoFields = elemTypeInfo.fields || {}
-      const typeInfoFieldNames = Object.keys(typeInfoFields)
+      const typeInfoFields = elemTypeInfo.fields || []
+      const typeInfoFieldNames = typeInfoFields.map((field) => field.name)
       const parsedFieldNames = Object.keys(parsedFields)
 
       if (typeInfoFieldNames.length !== parsedFieldNames.length) {
@@ -1045,16 +1229,13 @@ function compareTypeStringWithTypeInfo(
       }
 
       // Check if all field names match and types are compatible
-      for (const fieldName of typeInfoFieldNames) {
+      for (const field of typeInfoFields) {
+        const fieldName = field.name
         if (!(fieldName in parsedFields)) {
           return false
         }
 
-        const fieldValue = typeInfoFields[fieldName]
-        // Handle StructFieldInfo (which has 'type' and optional 'tag' properties)
-        const fieldTypeInfo: TypeInfo | string =
-          isStructFieldInfo(fieldValue) ? fieldValue.type : fieldValue
-        const typeInfoFieldType = normalizeTypeInfo(fieldTypeInfo)
+        const typeInfoFieldType = normalizeTypeInfo(field.type)
         const parsedFieldType = parsedFields[fieldName]
 
         // Compare basic types
@@ -1081,9 +1262,58 @@ function compareTypeStringWithTypeInfo(
     if (typeof elemType === 'string') {
       return elemStr === elemType
     }
-    if (elemType.name) {
-      return elemStr === elemType.name
+    return compareTypeStringWithTypeInfo(elemStr, elemType)
+  }
+
+  if (isSliceTypeInfo(normalized)) {
+    if (!typeStr.startsWith('[]') || !normalized.elemType) {
+      return false
+    }
+    return compareTypeStringWithTypeInfo(typeStr.slice(2), normalized.elemType)
+  }
+
+  if (isArrayTypeInfo(normalized)) {
+    const match = typeStr.match(/^\[(\d+)\](.+)$/)
+    if (!match || !normalized.elemType) {
+      return false
     }
+    return (
+      Number(match[1]) === normalized.length &&
+      compareTypeStringWithTypeInfo(match[2], normalized.elemType)
+    )
+  }
+
+  if (isBasicTypeInfo(normalized)) {
+    const name = typeInfoRuntimeName(normalized)
+    if (name === undefined) {
+      return false
+    }
+    if (typeStr === name) {
+      return true
+    }
+    if (name === 'uint8' && typeStr === 'byte') {
+      return true
+    }
+    if (name === 'int32' && typeStr === 'rune') {
+      return true
+    }
+    return (
+      name === 'int' &&
+      [
+        'byte',
+        'rune',
+        'int8',
+        'int16',
+        'int32',
+        'int64',
+        'uint',
+        'uint8',
+        'uint16',
+        'uint32',
+        'uint64',
+        'uintptr',
+      ].includes(typeStr)
+    )
   }
 
   return false
@@ -1369,10 +1599,12 @@ export function namedValueInterfaceValue<T>(
   value: unknown,
   typeName: string,
   methods: Record<string, (receiver: any, ...args: any[]) => any>,
+  typeInfo?: TypeInfo | string,
 ): T {
   const boxed: any = {
     __goType: typeName,
     __goValue: value,
+    __goTypeInfo: typeInfo,
     valueOf: () => value,
     toString: () => String(value),
     [Symbol.toPrimitive]: () => value as any,
@@ -1383,24 +1615,39 @@ export function namedValueInterfaceValue<T>(
   return boxed as T
 }
 
-export function namedFunction<T>(fn: T, typeName: string): T {
+export function namedFunction<T>(
+  fn: T,
+  typeName: string,
+  typeInfo?: FunctionTypeInfo,
+): T {
   if (typeof fn !== 'function') {
     return fn
   }
-  return Object.assign(fn, { __goTypeName: typeName })
+  return Object.assign(
+    fn,
+    typeInfo ?
+      { __goTypeName: typeName, __typeInfo: typeInfo }
+    : { __goTypeName: typeName },
+  )
 }
 
 export function functionValue<T extends (...args: any[]) => any>(
   fn: T,
   typeInfo: FunctionTypeInfo,
 ): T {
-  return Object.assign(fn, { __typeInfo: typeInfo })
+  return Object.assign(
+    fn,
+    typeInfo.name ?
+      { __typeInfo: typeInfo, __goTypeName: typeInfo.name }
+    : { __typeInfo: typeInfo },
+  )
 }
 
 export interface GenericTypeDescriptor<T = any> {
   type?: TypeInfo | string
   zero?: () => T
   methods?: Record<string, (receiver: T, ...args: any[]) => any>
+  methodSignatures?: MethodSignature[]
 }
 
 export type GenericTypeArgs = Record<string, GenericTypeDescriptor>