stone-lang 0.1.0

package/frontend/type-checker/typeCompatibility.js

@@ -0,0 +1,389 @@
+/**
+ * Type Compatibility Methods - mixin for TypeChecker
+ *
+ * Methods for type comparison, promotion, unification, and conversion
+ * between class-based and structured type representations.
+ */
+
+import {
+  PrimitiveType,
+  FunctionType,
+  RecordType,
+  ArrayType,
+  TypeVariable,
+  PromotedType,
+  NUM,
+  BOOL,
+  STRING,
+  UNIT,
+  freshTypeVar,
+  typeEquals,
+} from "../types/types.js";
+
+/**
+ * Type compatibility methods to be mixed into TypeChecker.prototype
+ */
+export const typeCompatibilityMethods = {
+  /**
+   * Check if a class-based type contains unresolved type variables
+   */
+  containsUnresolvedTypeVar(type) {
+    if (!type) return false;
+    if (type instanceof TypeVariable) {
+      const resolved = type.resolve();
+      if (resolved instanceof TypeVariable) return true;
+      return this.containsUnresolvedTypeVar(resolved);
+    }
+    if (type instanceof ArrayType) {
+      return this.containsUnresolvedTypeVar(type.elementType);
+    }
+    if (type instanceof FunctionType) {
+      if (type.paramTypes.some(p => this.containsUnresolvedTypeVar(p))) return true;
+      return this.containsUnresolvedTypeVar(type.returnType);
+    }
+    if (type instanceof RecordType) {
+      for (const fieldType of type.fields.values()) {
+        if (this.containsUnresolvedTypeVar(fieldType)) return true;
+      }
+    }
+    return false;
+  },
+
+  /**
+   * Check if a type is "incomplete" - contains unresolved TypeVariables
+   * Incomplete types need to be inferred from context (e.g., empty arrays)
+   */
+  isIncompleteType(type) {
+    if (type instanceof TypeVariable) {
+      const resolved = type.resolve();
+      return resolved instanceof TypeVariable;
+    }
+    if (type instanceof ArrayType) {
+      return this.isIncompleteType(type.elementType);
+    }
+    if (type instanceof RecordType) {
+      for (const fieldType of type.fields.values()) {
+        if (this.isIncompleteType(fieldType)) return true;
+      }
+    }
+    return false;
+  },
+
+  /**
+   * Convert a class-based type to a structured type object for matching
+   * @param {Object} type - Class-based type (PrimitiveType, ArrayType, etc.)
+   * @returns {Object} Structured type object
+   */
+  toStructuredType(type) {
+    if (!type) return { kind: "unknown" };
+
+    // Already a plain structured object (not a class instance)
+    // Check for constructor being Object to distinguish from class instances
+    if (type.kind && type.constructor === Object) {
+      return type;
+    }
+
+    if (type instanceof PrimitiveType) {
+      return { kind: "primitive", name: type.name };
+    }
+
+    if (type instanceof ArrayType) {
+      return {
+        kind: "array",
+        elem: this.toStructuredType(type.elementType),  // Use 'elem' to match parseTypeString format
+        rank: type.rank,
+      };
+    }
+
+    if (type instanceof RecordType) {
+      const fields = new Map();
+      for (const [name, fieldType] of type.fields) {
+        fields.set(name, this.toStructuredType(fieldType));
+      }
+      return { kind: "record", fields, open: type.open };
+    }
+
+    if (type instanceof FunctionType) {
+      return {
+        kind: "function",
+        params: type.paramTypes.map(t => this.toStructuredType(t)),
+        ret: this.toStructuredType(type.returnType),
+      };
+    }
+
+    if (type instanceof TypeVariable) {
+      const resolved = type.resolve();
+      if (resolved !== type) {
+        return this.toStructuredType(resolved);
+      }
+      // Track the TypeVariable object for later unification
+      this.typeVarMap.set(type.id, type);
+      return { kind: "typevar", id: type.id, resolved: null };
+    }
+
+    return { kind: "unknown" };
+  },
+
+  /**
+   * Check if a structured type contains unresolved type variables
+   */
+  hasUnresolvedTypeVars(type) {
+    if (!type) return false;
+    if (type.kind === "typevar" && !type.resolved) return true;
+    if (type.kind === "unknown") return true;
+    if (type.kind === "array") return this.hasUnresolvedTypeVars(type.elem);
+    if (type.kind === "list") return this.hasUnresolvedTypeVars(type.elem);
+    if (type.kind === "function") {
+      if (type.params?.some(p => this.hasUnresolvedTypeVars(p))) return true;
+      return this.hasUnresolvedTypeVars(type.ret);
+    }
+    return false;
+  },
+
+  /**
+   * Check if two function types can unify, treating type variables as wildcards.
+   * This is used for matching function arguments with type variables against
+   * expected function parameter types.
+   * E.g., (T1, T2) -> array<num,1> can unify with (num, array<num,1>) -> array<num,1>
+   */
+  canUnifyFunctionTypes(expected, actual) {
+    if (!(expected instanceof FunctionType) || !(actual instanceof FunctionType)) {
+      return false;
+    }
+
+    // Must have same arity
+    if (expected.paramTypes.length !== actual.paramTypes.length) {
+      return false;
+    }
+
+    // Check each parameter type
+    for (let i = 0; i < expected.paramTypes.length; i++) {
+      const expParam = expected.paramTypes[i];
+      const actParam = actual.paramTypes[i];
+
+      // Type variable can match anything
+      if (expParam instanceof TypeVariable || actParam instanceof TypeVariable) {
+        continue;
+      }
+
+      // Both must be the same type or unifiable
+      if (!this.typesEqual(expParam, actParam) && !this.canUnifyTypes(expParam, actParam)) {
+        return false;
+      }
+    }
+
+    // Check return type (type variable in return is also allowed)
+    const expRet = expected.returnType;
+    const actRet = actual.returnType;
+
+    if (expRet instanceof TypeVariable || actRet instanceof TypeVariable) {
+      return true;
+    }
+
+    return this.typesEqual(expRet, actRet) || this.canUnifyTypes(expRet, actRet);
+  },
+
+  /**
+   * Check if two types can unify (type variables match anything)
+   */
+  canUnifyTypes(a, b) {
+    if (a instanceof TypeVariable || b instanceof TypeVariable) {
+      return true;
+    }
+    if (a instanceof ArrayType && b instanceof ArrayType) {
+      return this.canUnifyTypes(a.elementType, b.elementType);
+    }
+    if (a instanceof FunctionType && b instanceof FunctionType) {
+      return this.canUnifyFunctionTypes(a, b);
+    }
+    return this.typesEqual(a, b);
+  },
+
+  /**
+   * Check if two types are equal
+   * For PromotedType, compares against the target type or source type
+   */
+  typesEqual(a, b) {
+    if (a === b) return true;
+    if (!a || !b) return false;
+
+    // Handle PromotedType: compare against target type or source type
+    if (a instanceof PromotedType) {
+      // If b matches target type, it's equal (no promotion needed)
+      if (this.typesEqual(a.targetType, b)) return true;
+      // If b matches source type, it's also considered equal for overload matching
+      // (the actual promotion will be handled by canPromote)
+      if (a.sourceType && this.typesEqual(a.sourceType, b)) return true;
+      return false;
+    }
+    if (b instanceof PromotedType) {
+      // Symmetric case
+      if (this.typesEqual(a, b.targetType)) return true;
+      if (b.sourceType && this.typesEqual(a, b.sourceType)) return true;
+      return false;
+    }
+
+    if (a.constructor !== b.constructor) return false;
+
+    if (a instanceof ArrayType) {
+      return this.typesEqual(a.elementType, b.elementType) && a.rank === b.rank;
+    }
+
+    if (a instanceof FunctionType) {
+      if (a.paramTypes.length !== b.paramTypes.length) return false;
+      for (let i = 0; i < a.paramTypes.length; i++) {
+        if (!this.typesEqual(a.paramTypes[i], b.paramTypes[i])) return false;
+      }
+      return this.typesEqual(a.returnType, b.returnType);
+    }
+
+    if (a instanceof RecordType) {
+      if (a.fields.size !== b.fields.size) return false;
+      for (const [name, type] of a.fields) {
+        if (!b.fields.has(name) || !this.typesEqual(type, b.fields.get(name))) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    // Primitive types - compare by reference (NUM, BOOL, etc.)
+    return a === b;
+  },
+
+  /**
+   * Check if a type is the complex record type {re: num, im: num}
+   */
+  isComplexRecordType(type) {
+    if (!(type instanceof RecordType)) return false;
+    if (type.fields.size !== 2) return false;
+    const reType = type.fields.get("re");
+    const imType = type.fields.get("im");
+    if (!reType || !imType) return false;
+    return reType === NUM && imType === NUM;
+  },
+
+  /**
+   * Check if argType can be promoted to paramType.
+   * Supports both built-in promotions (num → complex) and user-defined
+   * promotions via PromotedType.
+   *
+   * @param {Object} argType - Argument type (class-based)
+   * @param {Object} paramType - Parameter type (may be PromotedType)
+   * @returns {{can: boolean, converter: string|null}} Promotion result
+   */
+  canPromote(argType, paramType) {
+    // Handle PromotedType: check if argType matches the sourceType
+    if (paramType instanceof PromotedType) {
+      // If sourceType is set (validated), check if argType matches it
+      if (paramType.sourceType && typeEquals(argType, paramType.sourceType)) {
+        return { can: true, converter: paramType.converterFunc };
+      }
+      // Also check if argType matches the target type (no conversion needed)
+      if (typeEquals(argType, paramType.targetType)) {
+        return { can: false, converter: null }; // No promotion needed - exact match
+      }
+      return { can: false, converter: null };
+    }
+
+    // Built-in: num -> complex (complex is now {re: num, im: num} record)
+    if (argType === NUM && this.isComplexRecordType(paramType)) {
+      return { can: true, converter: "to_complex" };
+    }
+    // Built-in: array<num> -> array<complex> promotion
+    if (argType instanceof ArrayType && paramType instanceof ArrayType) {
+      if (argType.rank === paramType.rank) {
+        const elemResult = this.canPromote(argType.elementType, paramType.elementType);
+        return elemResult;
+      }
+    }
+    return { can: false, converter: null };
+  },
+
+  /**
+   * Check if types are compatible (looser than equal)
+   */
+  typesCompatible(paramType, argType) {
+    // Arrays with same element type but different ranks might be compatible
+    // depending on context - be lenient here
+    if (paramType instanceof ArrayType && argType instanceof ArrayType) {
+      return this.typesEqual(paramType.elementType, argType.elementType) ||
+             this.typesCompatible(paramType.elementType, argType.elementType);
+    }
+    // Records with subset of fields
+    if (paramType instanceof RecordType && argType instanceof RecordType) {
+      for (const [name, type] of paramType.fields) {
+        if (!argType.fields.has(name)) return false;
+        if (!this.typesCompatible(type, argType.fields.get(name))) return false;
+      }
+      return true;
+    }
+    return false;
+  },
+
+  /**
+   * Check if types are compatible or can unify (for Phase 1.5 filtering)
+   */
+  typesCompatibleOrUnifiable(actual, expected) {
+    if (actual instanceof TypeVariable || expected instanceof TypeVariable) {
+      return true;
+    }
+    if (this.typesEqual(actual, expected)) {
+      return true;
+    }
+    if (this.canPromote(actual, expected).can) {
+      return true;
+    }
+    if (this.typesCompatible(expected, actual)) {
+      return true;
+    }
+    if (actual instanceof ArrayType && expected instanceof ArrayType) {
+      return this.typesCompatibleOrUnifiable(actual.elementType, expected.elementType);
+    }
+    return false;
+  },
+
+  /**
+   * Convert structured type back to class-based type
+   * @param {Object} type - Structured type object
+   * @returns {Object} Class-based type
+   */
+  fromStructuredType(type) {
+    if (!type) return freshTypeVar();
+
+    if (type.kind === "primitive") {
+      switch (type.name) {
+        case "num": return NUM;
+        case "bool": return BOOL;
+        case "string": return STRING;
+        case "unit": return UNIT;
+        // Note: "complex" is no longer a primitive - it's a record {re: num, im: num}
+        // The "record" case below will handle it
+        default: return freshTypeVar();
+      }
+    }
+
+    if (type.kind === "array") {
+      const elemType = this.fromStructuredType(type.elem);
+      return new ArrayType(elemType, type.rank);
+    }
+
+    // list<T> is deprecated - treat as array<T,1> for backwards compatibility
+    if (type.kind === "list") {
+      const elemType = this.fromStructuredType(type.elem);
+      return new ArrayType(elemType, 1);
+    }
+
+    if (type.kind === "record") {
+      const fields = new Map();
+      if (type.fields instanceof Map) {
+        for (const [name, fieldType] of type.fields) {
+          fields.set(name, this.fromStructuredType(fieldType));
+        }
+      }
+      return new RecordType(fields, type.open || false);
+    }
+
+    return freshTypeVar();
+  },
+};