goscript 0.0.21 → 0.0.22

package/builtin/builtin.ts

@@ -724,12 +724,29 @@ export interface BaseTypeInfo {
   zeroValue?: any
 }
 
+/**
+ * Represents an argument or a return value of a method.
+ */
+export interface MethodArg {
+  name?: string; // Name of the argument/return value, if available
+  type: TypeInfo | string; // TypeInfo object or string name of the type
+}
+
+/**
+ * Represents the signature of a method, including its name, arguments, and return types.
+ */
+export interface MethodSignature {
+  name: string;
+  args: MethodArg[];
+  returns: MethodArg[];
+}
+
 /**
  * Type information for struct types
  */
 export interface StructTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Struct
-  methods: Set<string>
+  methods: MethodSignature[] // Array of method signatures
   ctor?: new (...args: any[]) => any
   fields: Record<string, TypeInfo | string> // Field names and types for struct fields
 }
@@ -739,7 +756,7 @@ export interface StructTypeInfo extends BaseTypeInfo {
  */
 export interface InterfaceTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Interface
-  methods: Set<string>
+  methods: MethodSignature[] // Array of method signatures
 }
 
 /**
@@ -790,6 +807,7 @@ export interface FunctionTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Function
   params?: (string | TypeInfo)[]
   results?: (string | TypeInfo)[]
+  isVariadic?: boolean // True if the function is variadic (e.g., ...T)
 }
 
 /**
@@ -860,14 +878,15 @@ const typeRegistry = new Map<string, TypeInfo>()
  *
  * @param name The name of the type.
  * @param zeroValue The zero value for the type.
- * @param methods Set of method names for the struct.
+ * @param methods Array of method signatures for the struct.
  * @param ctor Constructor for the struct.
+ * @param fields Record of field names and their types.
  * @returns The struct type information object.
  */
 export const registerStructType = (
   name: string,
   zeroValue: any,
-  methods: Set<string>,
+  methods: MethodSignature[],
   ctor: new (...args: any[]) => any,
   fields: Record<string, TypeInfo | string> = {},
 ): StructTypeInfo => {
@@ -888,13 +907,13 @@ export const registerStructType = (
  *
  * @param name The name of the type.
  * @param zeroValue The zero value for the type (usually null).
- * @param methods Set of method names the interface requires.
+ * @param methods Array of method signatures for the interface.
  * @returns The interface type information object.
  */
 export const registerInterfaceType = (
   name: string,
   zeroValue: any,
-  methods: Set<string>,
+  methods: MethodSignature[],
 ): InterfaceTypeInfo => {
   const typeInfo: InterfaceTypeInfo = {
     name,
@@ -935,6 +954,147 @@ function normalizeTypeInfo(info: string | TypeInfo): TypeInfo {
   return info
 }
 
+function compareOptionalTypeInfo(
+  type1?: string | TypeInfo,
+  type2?: string | TypeInfo,
+): 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)
+}
+
+function areFuncParamOrResultArraysIdentical(
+  arr1?: (string | TypeInfo)[],
+  arr2?: (string | TypeInfo)[]
+): 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])) {
+      return false
+    }
+  }
+  return true
+}
+
+function areFuncSignaturesIdentical(
+  func1: FunctionTypeInfo,
+  func2: FunctionTypeInfo,
+): boolean {
+  if ((func1.isVariadic || false) !== (func2.isVariadic || false)) {
+    return false
+  }
+  return (
+    areFuncParamOrResultArraysIdentical(func1.params, func2.params) &&
+    areFuncParamOrResultArraysIdentical(func1.results, func2.results)
+  )
+}
+
+function areMethodArgsArraysIdentical(
+  args1?: MethodArg[],
+  args2?: MethodArg[],
+): boolean {
+  if (args1 === undefined && args2 === undefined) return true
+  if (args1 === undefined || args2 === undefined) return false
+  if (args1.length !== args2.length) return false
+  for (let i = 0; i < args1.length; i++) {
+    // Compare based on type only, names of args/results don't affect signature identity here.
+    if (!areTypeInfosIdentical(args1[i].type, args2[i].type)) {
+      return false
+    }
+  }
+  return true
+}
+
+export function areTypeInfosIdentical(
+  type1InfoOrName: string | TypeInfo,
+  type2InfoOrName: string | TypeInfo,
+): boolean {
+  const t1Norm = normalizeTypeInfo(type1InfoOrName)
+  const t2Norm = normalizeTypeInfo(type2InfoOrName)
+
+  if (t1Norm === t2Norm) return true // Object identity
+  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.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.kind === TypeKind.Struct ||
+      t1Norm.kind === TypeKind.Interface
+    ) {
+      return true
+    }
+  }
+  // For other types (Pointer, Slice, etc.), or if both are anonymous (name is undefined),
+  // structural comparison is needed.
+
+  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,
+      )
+    case TypeKind.Slice:
+      return compareOptionalTypeInfo(
+        (t1Norm as SliceTypeInfo).elemType,
+        (t2Norm as SliceTypeInfo).elemType,
+      )
+    case TypeKind.Array:
+      return (
+        (t1Norm as ArrayTypeInfo).length === (t2Norm as ArrayTypeInfo).length &&
+        compareOptionalTypeInfo(
+          (t1Norm as ArrayTypeInfo).elemType,
+          (t2Norm as ArrayTypeInfo).elemType,
+        )
+      )
+    case TypeKind.Map:
+      return (
+        compareOptionalTypeInfo(
+          (t1Norm as MapTypeInfo).keyType,
+          (t2Norm as MapTypeInfo).keyType,
+        ) &&
+        compareOptionalTypeInfo(
+          (t1Norm as MapTypeInfo).elemType,
+          (t2Norm as MapTypeInfo).elemType,
+        )
+      )
+    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,
+        )
+      )
+    case TypeKind.Function:
+      return areFuncSignaturesIdentical(
+        t1Norm as FunctionTypeInfo,
+        t2Norm as FunctionTypeInfo,
+      )
+    case TypeKind.Struct:
+    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
+    default:
+      return false
+  }
+}
+
 /**
  * Validates that a map key matches the expected type info.
  *
@@ -993,16 +1153,20 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
     return true
   }
 
+  // Check if the value has all methods defined in the struct's TypeInfo
+  // This is a structural check, not a signature check here.
+  // Signature checks are more relevant for interface satisfaction.
   if (info.methods && typeof value === 'object' && value !== null) {
-    const allMethodsMatch = Array.from(info.methods).every(
-      (method) => typeof value[method] === 'function',
+    const allMethodsExist = info.methods.every(
+      (methodSig) => typeof (value as any)[methodSig.name] === 'function',
     )
-    if (allMethodsMatch) {
-      return true
+    if (!allMethodsExist) {
+      return false
     }
+    // Further signature checking could be added here if needed for struct-to-struct assignability
   }
 
-  if (typeof value === 'object' && value !== null) {
+  if (typeof value === 'object' && value !== null && info.fields) {
     const fieldNames = Object.keys(info.fields || {})
     const valueFields = Object.keys(value)
 
@@ -1034,19 +1198,96 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
  * @param info The interface type info to match against.
  * @returns True if the value matches the interface type, false otherwise.
  */
+/**
+ * Checks if a value matches an interface type info by verifying it implements
+ * all required methods with compatible signatures.
+ *
+ * @param value The value to check.
+ * @param info The interface type info to match against.
+ * @returns True if the value matches the interface type, false otherwise.
+ */
 function matchesInterfaceType(value: any, info: TypeInfo): boolean {
-  // For interfaces, check if the value has all the required methods
-  if (
-    isInterfaceTypeInfo(info) &&
-    info.methods &&
-    typeof value === 'object' &&
-    value !== null
-  ) {
-    return Array.from(info.methods).every(
-      (method) => typeof (value as any)[method] === 'function',
-    )
+  // Check basic conditions first
+  if (!isInterfaceTypeInfo(info) || typeof value !== 'object' || value === null) {
+    return false
   }
-  return false
+
+  // For interfaces, check if the value has all the required methods with compatible signatures
+  return info.methods.every((requiredMethodSig) => {
+    const actualMethod = (value as any)[requiredMethodSig.name]
+    
+    // Method must exist and be a function
+    if (typeof actualMethod !== 'function') {
+      return false
+    }
+
+    // Check parameter count (basic arity check)
+    // Note: This is a simplified check as JavaScript functions can have optional/rest parameters
+    const declaredParamCount = actualMethod.length
+    const requiredParamCount = requiredMethodSig.args.length
+    
+    // Strict arity checking can be problematic in JS, so we'll be lenient
+    // A method with fewer params than required is definitely incompatible
+    if (declaredParamCount < requiredParamCount) {
+      return false
+    }
+    
+    // Check return types if we can determine them
+    // This is challenging in JavaScript without runtime type information
+    
+    // If the value has a __goTypeName property, it might be a registered type
+    // with more type information available
+    if (value.__goTypeName) {
+      const valueTypeInfo = typeRegistry.get(value.__goTypeName)
+      if (valueTypeInfo && isStructTypeInfo(valueTypeInfo)) {
+        // Find the matching method in the value's type info
+        const valueMethodSig = valueTypeInfo.methods.find(
+          m => m.name === requiredMethodSig.name
+        )
+        
+        if (valueMethodSig) {
+          // Compare return types
+          if (valueMethodSig.returns.length !== requiredMethodSig.returns.length) {
+            return false
+          }
+          
+          // Compare each return type for compatibility
+          for (let i = 0; i < requiredMethodSig.returns.length; i++) {
+            const requiredReturnType = normalizeTypeInfo(
+              requiredMethodSig.returns[i].type
+            )
+            const valueReturnType = normalizeTypeInfo(
+              valueMethodSig.returns[i].type
+            )
+            
+            // For interface return types, we need to check if the value's return type
+            // implements the required interface
+            if (isInterfaceTypeInfo(requiredReturnType)) {
+              // This would be a recursive check, but we'll simplify for now
+              // by just checking if the types are the same or if the value type
+              // is registered as implementing the interface
+              if (requiredReturnType.name !== valueReturnType.name) {
+                // Check if valueReturnType implements requiredReturnType
+                // This would require additional implementation tracking
+                return false
+              }
+            } 
+            // For non-interface types, check direct type compatibility
+            else if (requiredReturnType.name !== valueReturnType.name) {
+              return false
+            }
+          }
+          
+          // Similarly, we could check parameter types for compatibility
+          // but we'll skip that for brevity
+        }
+      }
+    }
+    
+    // If we can't determine detailed type information, we'll accept the method
+    // as long as it exists with a compatible arity
+    return true
+  })
 }
 
 /**
@@ -1297,22 +1538,46 @@ export function typeAssert<T>(
 
   if (
     isStructTypeInfo(normalizedType) &&
-    normalizedType.methods &&
+    normalizedType.methods && normalizedType.methods.length > 0 &&
     typeof value === 'object' &&
     value !== null
   ) {
-    // Check if the value implements all methods of the struct type
-    const allMethodsMatch = Array.from(normalizedType.methods).every(
-      (method) => typeof value[method] === 'function',
-    )
+    // Check if the value implements all methods of the struct type with compatible signatures.
+    // This is more for interface satisfaction by a struct.
+    // For struct-to-struct assertion, usually instanceof or field checks are primary.
+    const allMethodsMatch = normalizedType.methods.every((requiredMethodSig) => {
+      const actualMethod = (value as any)[requiredMethodSig.name];
+      if (typeof actualMethod !== 'function') {
+        return false;
+      }
+      const valueTypeInfoVal = (value as any).$typeInfo
+      if (valueTypeInfoVal) {
+        const normalizedValueType = normalizeTypeInfo(valueTypeInfoVal)
+        if (isStructTypeInfo(normalizedValueType) || isInterfaceTypeInfo(normalizedValueType)) {
+          const actualValueMethodSig = normalizedValueType.methods.find(m => m.name === requiredMethodSig.name)
+          if (actualValueMethodSig) {
+            // Perform full signature comparison using MethodSignatures
+            const paramsMatch = areMethodArgsArraysIdentical(requiredMethodSig.args, actualValueMethodSig.args)
+            const resultsMatch = areMethodArgsArraysIdentical(requiredMethodSig.returns, actualValueMethodSig.returns)
+            return paramsMatch && resultsMatch
+          } else {
+            // Value has TypeInfo listing methods, but this specific method isn't listed.
+            // This implies a mismatch for strict signature check based on TypeInfo.
+            return false
+          }
+        }
+      }
 
-    const hasAnyMethod = Array.from(normalizedType.methods).some(
-      (method) => typeof value[method] === 'function',
-    )
+      // Fallback: Original behavior if value has no TypeInfo that lists methods,
+      // or if the method wasn't found in its TypeInfo (covered by 'else' returning false above).
+      // The original comment was: "For now, presence and function type is checked by matchesStructType/matchesInterfaceType"
+      // This 'return true' implies that if we couldn't do a full signature check via TypeInfo,
+      // we still consider it a match if the function simply exists on the object.
+      return true;
+    });
 
-    if (allMethodsMatch && hasAnyMethod && normalizedType.methods.size > 0) {
-      // For interface-to-concrete type assertions, we just need to check methods
-      return { value: value as T, ok: true }
+    if (allMethodsMatch) {
+      return { value: value as T, ok: true };
     }
   }