stone-lang 0.1.0

package/frontend/type-checker/visitors/literals.js

@@ -0,0 +1,341 @@
+/**
+ * Literal Visitors - mixin for TypeChecker
+ *
+ * Visitors for literals, identifiers, arrays, objects, and binding structures.
+ */
+
+import {
+  ArrayType,
+  RecordType,
+  TypeVariable,
+  NUM,
+  BOOL,
+  STRING,
+  UNIT,
+  LiteralType,
+  freshTypeVar,
+  typeEquals,
+  isNumeric,
+  numericPromotion,
+  unify,
+  formatType,
+  fromTypeAnnotation,
+} from "../../types/types.js";
+import { OverloadedFunctionType } from "../OverloadedFunctionType.js";
+
+/**
+ * Literal visitor methods to be mixed into TypeChecker.prototype
+ */
+export const literalVisitors = {
+  /**
+   * Visit a program
+   */
+  visitProgram(node, env) {
+    for (const stmt of node.statements) {
+      this.visit(stmt, env);
+    }
+    return UNIT;
+  },
+
+  /**
+   * Main visitor dispatch
+   */
+  visit(node, env) {
+    if (!node) return UNIT;
+
+    const methodName = `visit${node.type}`;
+    if (typeof this[methodName] === "function") {
+      return this[methodName](node, env);
+    }
+
+    // Unknown node type - return fresh type variable
+    return this.setType(node, freshTypeVar());
+  },
+
+  /**
+   * Visit a literal and infer its type
+   * @param {Object} node - Literal AST node
+   * @param {TypeEnvironment} env - Type environment
+   * @returns {Object} Inferred type
+   *
+   * For string and number literals, we infer LiteralType to enable
+   * compile-time checking against literal constraints.
+   * Example: "on" gets type LiteralType("on", "string"), not STRING
+   */
+  visitLiteral(node, env) {
+    let type;
+    switch (node.literalType) {
+      case "number":
+        // Infer literal type for numbers to support literal constraints like level: 0 | 1 | 2
+        type = new LiteralType(node.value, "num");
+        break;
+      case "complex": {
+        // Complex is now a record type {re: num, im: num}
+        const fields = new Map();
+        fields.set("re", NUM);
+        fields.set("im", NUM);
+        type = new RecordType(fields, false);
+        break;
+      }
+      case "string":
+        // Infer literal type for strings to support literal constraints like mode: "on" | "off"
+        type = new LiteralType(node.value, "string");
+        break;
+      case "bool":
+        type = BOOL;
+        break;
+      case "none":
+        type = UNIT;
+        break;
+      default:
+        type = freshTypeVar();
+    }
+    return this.setType(node, type);
+  },
+
+  /**
+   * Visit an identifier
+   */
+  visitIdentifier(node, env) {
+    const type = env.lookup(node.name);
+    if (!type) {
+      // Check if this is a known overloaded primitive function
+      if (this.overloads[node.name]) {
+        // It's an overloaded primitive - create an OverloadedFunctionType
+        return this.setType(node, new OverloadedFunctionType(node.name, this.overloads[node.name]));
+      }
+
+      // Unknown identifier - report error for undefined variable
+      this.addError(`Undefined variable: ${node.name}`, node.location);
+
+      // Still return a fresh type variable for error recovery
+      // This allows type checking to continue and catch other errors
+      return this.setType(node, freshTypeVar());
+    }
+    return this.setType(node, type);
+  },
+
+  /**
+   * Visit an array literal
+   * Always creates Array<T, R> type (lists are disabled for now)
+   */
+  visitArrayLiteral(node, env) {
+    if (node.elements.length === 0) {
+      // Empty array - element type is inferred from usage (e.g., push operations)
+      return this.setType(node, new ArrayType(freshTypeVar(), 1));
+    }
+
+    // Infer types of all elements
+    const elementTypes = node.elements.map((elem) => this.visit(elem, env));
+
+    // Check if rectangular (for Array type)
+    const { isRectangular, shape, baseType } = this.analyzeArrayStructure(
+      node,
+      elementTypes,
+      env
+    );
+
+    if (isRectangular && baseType && isNumeric(baseType)) {
+      // Dense numeric array: Array<T, R>
+      const rank = shape.length;
+      return this.setType(node, new ArrayType(baseType, rank));
+    } else {
+      // Non-rectangular or non-numeric - still create Array with inferred element type
+      // For now, treat as 1D array of the unified element type
+      const elemType = this.unifyTypes(elementTypes, node.location);
+      return this.setType(node, new ArrayType(elemType, 1));
+    }
+  },
+
+  /**
+   * Analyze array structure to determine if rectangular
+   */
+  analyzeArrayStructure(node, elementTypes, env) {
+    if (node.elements.length === 0) {
+      return { isRectangular: true, shape: [0], baseType: freshTypeVar() };
+    }
+
+    // Check if all elements are the same type
+    const firstType = elementTypes[0];
+
+    // If first element is also an array, check nested structure
+    if (firstType instanceof ArrayType) {
+      // Check all elements have same rank and element type
+      for (const elemType of elementTypes) {
+        if (!(elemType instanceof ArrayType)) {
+          return { isRectangular: false, shape: null, baseType: null };
+        }
+        if (elemType.rank !== firstType.rank) {
+          return { isRectangular: false, shape: null, baseType: null };
+        }
+        if (!typeEquals(elemType.elementType, firstType.elementType)) {
+          return { isRectangular: false, shape: null, baseType: null };
+        }
+      }
+      // Rectangular: total rank = 1 (outer) + inner rank
+      // Shape array needs enough elements to match total rank
+      const totalRank = 1 + firstType.rank;
+      const shape = new Array(totalRank).fill(node.elements.length);
+      return {
+        isRectangular: true,
+        shape: shape,  // shape.length = totalRank
+        baseType: firstType.elementType,
+      };
+    }
+
+    // Base case: all elements should be primitives
+    for (const elemType of elementTypes) {
+      if (elemType instanceof ArrayType) {
+        return { isRectangular: false, shape: null, baseType: null };
+      }
+    }
+
+    // All primitives - check if all numeric
+    const promotedType = this.unifyTypes(elementTypes, node.location);
+    if (isNumeric(promotedType)) {
+      return {
+        isRectangular: true,
+        shape: [node.elements.length],
+        baseType: promotedType,
+      };
+    }
+
+    return { isRectangular: false, shape: null, baseType: promotedType };
+  },
+
+  /**
+   * Unify multiple types into one
+   */
+  unifyTypes(types, location) {
+    if (types.length === 0) return freshTypeVar();
+    if (types.length === 1) return types[0];
+
+    let result = types[0];
+    for (let i = 1; i < types.length; i++) {
+      const unifyResult = unify(result, types[i]);
+      if (!unifyResult.success) {
+        // Try numeric promotion
+        const promoted = numericPromotion(result, types[i]);
+        if (promoted) {
+          result = promoted;
+        } else {
+          // Heterogeneous arrays are not allowed
+          this.addError(
+            `Heterogeneous array: cannot mix ${formatType(result)} and ${formatType(types[i])}`,
+            location
+          );
+          result = types[i]; // Continue with last type for further checking
+        }
+      } else {
+        // Unification succeeded, use resolved type
+        if (result instanceof TypeVariable) {
+          result = result.resolve();
+        }
+      }
+    }
+    return result;
+  },
+
+  /**
+   * Visit an object literal
+   */
+  visitObjectLiteral(node, env) {
+    // Empty object {} is an error
+    if (!node.properties || node.properties.length === 0) {
+      this.addError(
+        "Empty object literal {} is not allowed. Records must have at least one field.",
+        node.location
+      );
+      return this.setType(node, new RecordType(new Map(), false));
+    }
+
+    const fields = new Map();
+    for (const prop of node.properties) {
+      const valueType = this.visit(prop.value, env);
+      fields.set(prop.key, valueType);
+    }
+    return this.setType(node, new RecordType(fields, false));
+  },
+
+  /**
+   * Visit a binding structure
+   * Can be either:
+   * 1. Object literal: { x = 1, y = 2 } → RecordType
+   * 2. Block with bindings: { x = 1, y = 2, trailingExpr } → type of trailingExpr
+   */
+  visitBindingStructure(node, env) {
+    // Check if this is a block expression (has trailing expr or return statements)
+    const hasReturnBinding = node.bindings?.some(
+      (b) => !b.name && b.value && b.value.type === "ReturnStatement"
+    );
+
+    if (node.trailingExpr || hasReturnBinding) {
+      // Block with bindings that returns a value
+      const blockEnv = env.createChild();
+
+      // Type all bindings
+      for (const binding of node.bindings || []) {
+        if (binding.name) {
+          // Handle type descriptor bindings (may have null value)
+          if (binding.isTypeDescriptor) {
+            // Type descriptor: get type from annotation, optionally check default value
+            const declaredType = binding.typeAnnotation
+              ? fromTypeAnnotation(binding.typeAnnotation, blockEnv)
+              : freshTypeVar();
+            if (binding.value) {
+              // Has default value - type check it
+              const valueType = this.visit(binding.value, blockEnv);
+              // Could add unification here to ensure default matches declared type
+            }
+            blockEnv.define(binding.name, declaredType);
+          } else if (binding.value) {
+            const valueType = this.visit(binding.value, blockEnv);
+            blockEnv.define(binding.name, valueType);
+          }
+        } else if (binding.value) {
+          // Effect (null name) - just type check for side effects
+          this.visit(binding.value, blockEnv);
+        }
+      }
+
+      // Return type of trailing expression if present
+      if (node.trailingExpr) {
+        return this.setType(node, this.visit(node.trailingExpr, blockEnv));
+      }
+
+      return this.setType(node, UNIT);
+    }
+
+    // No trailing expression - this is an object literal (record)
+    const fields = new Map();
+    const requiredFields = new Set(); // Track type descriptors without defaults
+    let hasTypeDescriptors = false;
+
+    for (const binding of node.bindings || []) {
+      if (binding.name) {
+        // Handle type descriptor bindings (may have null value)
+        if (binding.isTypeDescriptor) {
+          hasTypeDescriptors = true;
+          // Type descriptor: get type from annotation
+          const declaredType = binding.typeAnnotation
+            ? fromTypeAnnotation(binding.typeAnnotation, env)
+            : freshTypeVar();
+          if (binding.value) {
+            // Has default value - type check it
+            this.visit(binding.value, env);
+          } else {
+            // No default value - this is a required field
+            requiredFields.add(binding.name);
+          }
+          fields.set(binding.name, declaredType);
+        } else if (binding.value) {
+          const valueType = this.visit(binding.value, env);
+          fields.set(binding.name, valueType);
+        }
+      }
+    }
+    // Only pass requiredFields if this is a schema record (has type descriptors)
+    const recordType = new RecordType(fields, false, false, hasTypeDescriptors ? requiredFields : null);
+    return this.setType(node, recordType);
+  },
+};

package/frontend/type-checker/visitors/modules.js

@@ -0,0 +1,159 @@
+/**
+ * Module Visitors - mixin for TypeChecker
+ *
+ * Visitors for import/export statements, type aliases, and block expressions.
+ */
+
+import {
+  RecordType,
+  UNIT,
+  STRING,
+  freshTypeVar,
+  fromTypeAnnotation,
+} from "../../types/types.js";
+import { OverloadedFunctionType } from "../OverloadedFunctionType.js";
+import { ExtensionInfo } from "../TypeEnvironment.js";
+
+/**
+ * Module visitor methods to be mixed into TypeChecker.prototype
+ */
+export const moduleVisitors = {
+  /**
+   * Visit a type alias declaration
+   * type Name = TypeAnnotation
+   */
+  visitTypeAlias(node, env) {
+    // Convert the type annotation to an internal type
+    const aliasedType = fromTypeAnnotation(node.typeAnnotation, env);
+
+    // Store in the environment's type alias registry
+    env.defineTypeAlias(node.name, aliasedType);
+
+    // Type alias declarations don't have a value, return unit
+    return this.setType(node, UNIT);
+  },
+
+  /**
+   * Visit an export statement
+   */
+  visitExportStatement(node, env) {
+    return this.visit(node.declaration, env);
+  },
+
+  /**
+   * Visit an import statement
+   * Resolves types from source module when possible for static type checking.
+   * Reports errors for imports that don't exist in the module.
+   */
+  visitImportStatement(node, env) {
+    // Register complex module overloads when any import from complex module is seen
+    // This allows operators like + - * / to work with complex numbers
+    if (node.modulePath === 'complex') {
+      this._registerComplexOverloads();
+    }
+
+    // Try to get types from the source module
+    const sourceExports = this.getModuleExportTypes(node.modulePath);
+    const sourceExtensions = sourceExports?._extensions || new Set();
+
+    for (const spec of node.specifiers) {
+      // Support both spec.name (old format) and spec.importedName (new format)
+      const importedName = spec.importedName || spec.name;
+      const localName = spec.localName || importedName;
+
+      if (sourceExports) {
+        const sourceType = sourceExports.get(importedName);
+        if (sourceType) {
+          // If it's an overloaded function, register it for overload resolution
+          if (sourceType instanceof OverloadedFunctionType) {
+            // Register the overloads in our overload registry for this import
+            if (!this.overloads[localName]) {
+              this.overloads[localName] = sourceType.overloads;
+            }
+            // Store overloadIds on the specifier for the compiler to use
+            // This enables compile-time resolution of cross-module overloads
+            spec.overloadIds = sourceType.userOverloads.map(o => o.overloadId);
+            spec.isOverloaded = true;
+          }
+          env.define(localName, sourceType);
+
+          // If this import is an extension function, register it as such
+          if (sourceExtensions.has(importedName)) {
+            // For imported extensions, we create minimal ExtensionInfo
+            // The selfType info comes from the function's first parameter (already captured in sourceType)
+            env.defineExtension(localName, new ExtensionInfo(localName, null, sourceType));
+          }
+
+          // Store type on specifier node for IDE hover support
+          this.setType(spec, sourceType);
+          continue;
+        }
+        // Module was analyzed but import name doesn't exist - report error
+        this.addError(
+          `'${importedName}' is not exported from module '${node.modulePath}'`,
+          spec.location || node.location
+        );
+      }
+      // Fall back to type variable to allow continued type checking
+      const typeVar = freshTypeVar();
+      env.define(localName, typeVar);
+      this.setType(spec, typeVar);
+    }
+    return UNIT;
+  },
+
+  /**
+   * Visit a namespace import statement
+   */
+  visitNamespaceImportStatement(node, env) {
+    const alias = node.alias || node.modulePath.split("/").pop();
+
+    // Try to get the actual exports from the module
+    const sourceExports = this.getModuleExportTypes(node.modulePath);
+
+    if (sourceExports && sourceExports.size > 0) {
+      // Create a record type with all the module's exports as fields
+      const fields = new Map();
+      for (const [name, type] of sourceExports) {
+        fields.set(name, type);
+        // Register overloaded functions for resolution
+        if (type instanceof OverloadedFunctionType) {
+          // Store with qualified name for potential future use
+          const qualifiedName = `${alias}.${name}`;
+          if (!this.overloads[qualifiedName]) {
+            this.overloads[qualifiedName] = type.overloads;
+          }
+        }
+      }
+      env.define(alias, new RecordType(fields, false));
+    } else {
+      // Fall back to open record if we can't analyze the module
+      env.define(alias, new RecordType(new Map(), true));
+    }
+    return UNIT;
+  },
+
+  /**
+   * Visit a block expression
+   */
+  visitBlockExpression(node, env) {
+    const blockEnv = env.createChild();
+    let lastType = UNIT;
+
+    for (const stmt of node.body) {
+      lastType = this.visit(stmt, blockEnv);
+    }
+
+    return this.setType(node, lastType);
+  },
+
+  /**
+   * Visit string interpolation
+   */
+  visitStringInterpolation(node, env) {
+    for (const expr of node.expressions) {
+      this.visit(expr, env);
+    }
+    return this.setType(node, STRING);
+  },
+};

package/frontend/type-checker/visitors/operators.js

@@ -0,0 +1,109 @@
+/**
+ * Operator Visitors - mixin for TypeChecker
+ *
+ * Visitors for binary and unary operations.
+ */
+
+import {
+  BOOL,
+  freshTypeVar,
+} from "../../types/types.js";
+import { BINARY_OP_NAMES, UNARY_OP_NAMES } from "../operatorMappings.js";
+
+/**
+ * Operator visitor methods to be mixed into TypeChecker.prototype
+ */
+export const operatorVisitors = {
+  /**
+   * Visit a binary operation
+   * Uses static overload resolution to determine result type.
+   * Checks user-defined overloads first, then falls back to primitives.
+   */
+  visitBinaryOp(node, env) {
+    const leftType = this.visit(node.left, env);
+    const rightType = this.visit(node.right, env);
+
+    const op = node.operator;
+
+    // Short-circuit logical operators don't go through overloads
+    if (op === "&&" || op === "||") {
+      return this.setType(node, BOOL);
+    }
+
+    // Map operator to function name
+    const funcName = BINARY_OP_NAMES[op];
+    if (funcName) {
+      // Use left operand's location for better error positioning
+      // (node.location points to after the expression, which is often wrong)
+      const errorLocation = node.left?.location || node.location;
+      const argTypes = [leftType, rightType];
+
+      // Operators only use built-in primitives, not user-defined functions
+      // Users cannot overload operators like + by defining 'add' functions
+      const outputType = this.resolveOverloadStatic(
+        funcName,
+        argTypes,
+        node,
+        errorLocation
+      );
+
+      if (outputType) {
+        // Convert structured type back to class-based type
+        const resultType = this.fromStructuredType(outputType);
+        return this.setType(node, resultType);
+      }
+
+      // Overload resolution failed - error already added
+      // Fall back to a reasonable type
+      if (["<", ">", "<=", ">=", "==", "!="].includes(op)) {
+        return this.setType(node, BOOL);
+      }
+      return this.setType(node, freshTypeVar());
+    }
+
+    // Unknown operator
+    return this.setType(node, freshTypeVar());
+  },
+
+  /**
+   * Visit a unary operation
+   * Uses static overload resolution to determine result type.
+   * Checks user-defined overloads first, then falls back to primitives.
+   */
+  visitUnaryOp(node, env) {
+    const operandType = this.visit(node.operand, env);
+
+    const op = node.operator;
+
+    // Map operator to function name
+    const funcName = UNARY_OP_NAMES[op];
+    if (funcName) {
+      // Use operand's location for better error positioning
+      const errorLocation = node.operand?.location || node.location;
+      const argTypes = [operandType];
+
+      // Operators only use built-in primitives, not user-defined functions
+      const outputType = this.resolveOverloadStatic(
+        funcName,
+        argTypes,
+        node,
+        errorLocation
+      );
+
+      if (outputType) {
+        const resultType = this.fromStructuredType(outputType);
+        return this.setType(node, resultType);
+      }
+
+      // Overload resolution failed - error already added
+      // Fall back based on operator
+      if (op === "!") {
+        return this.setType(node, BOOL);
+      }
+      return this.setType(node, operandType);
+    }
+
+    // Unknown operator - preserve operand type
+    return this.setType(node, operandType);
+  },
+};