stone-lang 0.1.0

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

@@ -0,0 +1,768 @@
+/**
+ * Statement Visitors - mixin for TypeChecker
+ *
+ * Visitors for assignments, destructuring, member access, ranges, etc.
+ */
+
+import {
+  FunctionType,
+  RecordType,
+  ArrayType,
+  TypeVariable,
+  PrimitiveType,
+  NUM,
+  INT,
+  STRING,
+  UNIT,
+  freshTypeVar,
+  unify,
+  formatType,
+  fromTypeAnnotation,
+} from "../../types/types.js";
+
+/**
+ * Statement visitor methods to be mixed into TypeChecker.prototype
+ */
+export const statementVisitors = {
+  /**
+   * Visit an assignment
+   */
+  visitAssignment(node, env) {
+    // Check for immutable variable rebinding (but allow primed variables like x')
+    // Skip this check for loop destructuring - the target in that case is a field name, not a binding
+    const targetName = node.target;
+    const isPrimedVariable = targetName && targetName.endsWith("'");
+    const isLoopDestructuring = node.value?.type === "LoopExpression" && node.value.destructuring;
+    if (!isPrimedVariable && !isLoopDestructuring && env.isImmutable(targetName)) {
+      this.addError(
+        `Cannot rebind immutable variable '${targetName}'. Variables in Stone are immutable once assigned.`,
+        node.location
+      );
+      // Continue type checking for error recovery
+    }
+
+    // Mark conditionals as value-producing (requires else branch)
+    if (node.value?.type === "BranchExpression") {
+      node.value._isValueProducing = true;
+    }
+
+    const valueType = this.visit(node.value, env);
+
+    // Handle loop destructuring: sumSq := loop(sumSq = 0) ~for(...) {...}
+    // The parser attaches destructuring info to the loop expression
+    // := ALWAYS destructures by field name (even for single target)
+    if (node.value?.type === "LoopExpression" && node.value.destructuring) {
+      const destructuring = node.value.destructuring;
+
+      // If value is a record, extract the destructured fields
+      if (valueType instanceof RecordType) {
+        // Extract each field by name
+        for (const target of destructuring) {
+          const fieldType = valueType.fields.get(target.name);
+          const varName = target.alias || target.name;
+          if (fieldType) {
+            env.define(varName, fieldType);
+            env.markImmutable(varName);
+          } else {
+            // All records are closed - missing field is an error
+            const availableFields = Array.from(valueType.fields.keys()).join(", ");
+            this.addError(
+              `Field '${target.name}' does not exist on loop result. ` +
+              `':=' destructures by field name. Available fields: ${availableFields}. ` +
+              `Use '=' instead to bind the entire loop state object to a single name.`,
+              target.location || node.location
+            );
+            env.define(varName, freshTypeVar());
+            env.markImmutable(varName);
+          }
+        }
+
+        // For single-field destructuring, the assigned variable gets the field type
+        if (destructuring.length === 1) {
+          const fieldType = valueType.fields.get(destructuring[0].name);
+          if (fieldType) {
+            return this.setType(node, fieldType);
+          }
+        }
+
+        return this.setType(node, UNIT);
+      }
+    }
+
+    // If there's a type annotation, check it matches
+    if (node.typeAnnotation) {
+      let annotatedType = fromTypeAnnotation(node.typeAnnotation, env);
+
+      // If annotatedType is a fresh TypeVariable, check if the annotation references
+      // a schema record variable (e.g., user1: userType where userType is a record)
+      let isSchemaRecord = false;
+      if (annotatedType instanceof TypeVariable && !annotatedType.resolved) {
+        if (node.typeAnnotation.kind === 'simple') {
+          const schemaName = node.typeAnnotation.details?.name || node.typeAnnotation.baseType;
+          if (schemaName) {
+            // Check if this variable exists in the environment
+            const schemaType = env.lookup(schemaName);
+            if (schemaType instanceof RecordType) {
+              // The schema is a record type - use it as the annotated type
+              // This enables: userType = {username: string, role: string = 'guest'}
+              //               user1: userType = {username = 'admin'}
+              annotatedType = schemaType;
+              isSchemaRecord = true;
+            }
+          }
+        }
+      }
+
+      // Special case: schema record with defaults
+      // When using a schema record as type annotation, the value may have fewer fields
+      // because defaults will be applied at runtime by APPLY_SCHEMA
+      if (isSchemaRecord && annotatedType instanceof RecordType && valueType instanceof RecordType) {
+        // Check that all fields in the value match the schema
+        let allFieldsValid = true;
+        for (const [fieldName, fieldType] of valueType.fields) {
+          const schemaFieldType = annotatedType.fields.get(fieldName);
+          if (!schemaFieldType) {
+            this.addError(
+              `Field '${fieldName}' does not exist in schema '${node.typeAnnotation.details?.name || node.typeAnnotation.baseType}'`,
+              node.location
+            );
+            allFieldsValid = false;
+          } else {
+            const fieldUnifyResult = unify(schemaFieldType, fieldType);
+            if (!fieldUnifyResult.success) {
+              this.addError(
+                `Type mismatch for field '${fieldName}': expected ${formatType(schemaFieldType)}, got ${formatType(fieldType)}`,
+                node.location
+              );
+              allFieldsValid = false;
+            }
+          }
+        }
+        // The variable gets an instance type derived from the schema
+        // (same fields, but without requiredFields so field access is allowed)
+        const instanceType = new RecordType(
+          annotatedType.fields,  // Same fields
+          false,                 // Not open
+          false,                 // Not explicit
+          null                   // No required fields - this is an instance, not a schema
+        );
+        env.define(node.target, instanceType);
+        if (!isPrimedVariable) {
+          env.markImmutable(node.target);
+        }
+        return this.setType(node, instanceType);
+      }
+
+      // Special case: empty array with annotation (e.g., arr: array<complex,1> = [])
+      // Resolve the fresh TypeVariable from [] to match the declared element type
+      if (annotatedType instanceof ArrayType &&
+          valueType instanceof ArrayType &&
+          valueType.elementType instanceof TypeVariable &&
+          !valueType.elementType.resolved) {
+        // Unify the fresh TypeVariable with the declared element type
+        unify(valueType.elementType, annotatedType.elementType);
+        // Store the declared type for push validation
+        env.defineDeclared(node.target, annotatedType);
+        env.define(node.target, annotatedType);
+        if (!isPrimedVariable) {
+          env.markImmutable(node.target);
+        }
+        return this.setType(node, annotatedType);
+      }
+
+      const unifyResult = unify(annotatedType, valueType);
+      if (!unifyResult.success) {
+        this.addError(
+          `Type mismatch: variable '${node.target}' declared as ${annotatedType}, but assigned ${valueType}`,
+          node.location
+        );
+      }
+      // Also store declared type for non-empty arrays with annotations
+      if (annotatedType instanceof ArrayType) {
+        env.defineDeclared(node.target, annotatedType);
+      }
+      env.define(node.target, annotatedType);
+      if (!isPrimedVariable) {
+        env.markImmutable(node.target);
+      }
+      return this.setType(node, annotatedType);
+    }
+
+    env.define(node.target, valueType);
+    if (!isPrimedVariable) {
+      env.markImmutable(node.target);
+    }
+    return this.setType(node, valueType);
+  },
+
+  /**
+   * Visit a destructuring assignment
+   */
+  visitDestructuringAssignment(node, env) {
+    const valueType = this.visit(node.value, env);
+
+    // Value should be a record type
+    if (!(valueType instanceof RecordType)) {
+      // Check if it's a concrete non-record type (not a TypeVariable)
+      if (!(valueType instanceof TypeVariable)) {
+        const typeStr = formatType(this.toStructuredType(valueType));
+        this.addError(
+          `Destructuring operator ':=' requires an object type, but got '${typeStr}'. ` +
+          `Arrays and primitives cannot be destructured with ':='.`,
+          node.location
+        );
+        // Define variables for error recovery
+        for (const target of node.targets) {
+          const name = target.alias || target.name;
+          env.define(name, freshTypeVar());
+          env.markImmutable(name);
+        }
+        return this.setType(node, UNIT);
+      }
+
+      // TypeVariable case: constrain it to be a record with the destructured fields
+      const fields = new Map();
+      for (const target of node.targets) {
+        const name = target.alias || target.name;
+        const fieldTypeVar = freshTypeVar();
+        fields.set(target.name, fieldTypeVar);  // Use target.name as field name (what we extract)
+        env.define(name, fieldTypeVar);
+        env.markImmutable(name);
+      }
+      const recordConstraint = new RecordType(fields, false, true); // explicit constraint from destructuring
+      unify(valueType, recordConstraint);
+      return this.setType(node, UNIT);
+    }
+
+    // Extract fields from known RecordType
+    for (const target of node.targets) {
+      const name = target.alias || target.name;
+      const fieldType = valueType.fields.get(target.name);
+      if (!fieldType) {
+        // All records are closed - missing field is an error
+        this.addError(
+          `Field '${target.name}' does not exist on record`,
+          target.location || node.location
+        );
+        env.define(name, freshTypeVar());
+        env.markImmutable(name);
+      } else {
+        env.define(name, fieldType);
+        env.markImmutable(name);
+      }
+    }
+
+    return this.setType(node, UNIT);
+  },
+
+  /**
+   * Visit an indexed assignment (mapping)
+   */
+  visitIndexedAssignment(node, env) {
+    // Create environment with index variables
+    const mappingEnv = env.createChild();
+    for (const index of node.indices) {
+      mappingEnv.define(index, INT);
+    }
+
+    // Track which indices are actually used so we don't double-warn
+    const unusedIndices = new Set();
+
+    // Check if each index variable is used in the RHS expression
+    for (const indexName of node.indices) {
+      if (!this.containsIdentifier(node.value, indexName)) {
+        const indicesStr = node.indices.join("][");
+        this.addError(
+          `Index variable '${indexName}' in mapping '${node.target}[${indicesStr}]' is not used in the expression. ` +
+          `The result won't vary with '${indexName}'.`,
+          node.location
+        );
+        unusedIndices.add(indexName);
+      }
+    }
+
+    // Additional validation: ensure each index drives at least one array access
+    if (unusedIndices.size === 0) {
+      if (node.indices.length === 1) {
+        const indexName = node.indices[0];
+        if (!this.findIndexedArray(node.value, indexName)) {
+          this.addError(
+            `No array found using index '${indexName}'`,
+            node.location
+          );
+        }
+      } else {
+        // Multi-dimensional mapping: either a single N-D array or one array per index
+        const ndArray = this.findNDIndexedArray(node.value, node.indices);
+        const arrayNodes = node.indices.map(idx => this.findIndexedArray(node.value, idx));
+        const hasAnyArrayNode = arrayNodes.some(node => node !== null);
+
+        if (!ndArray && !hasAnyArrayNode) {
+          this.addError(
+            `No arrays found using indices '${node.indices.join("', '")}'`,
+            node.location
+          );
+        } else if (!ndArray) {
+          for (let i = 0; i < node.indices.length; i++) {
+            if (arrayNodes[i] === null) {
+              const indexName = node.indices[i];
+              this.addError(
+                `Index '${indexName}' on left side has no corresponding indexed array on right side. ` +
+                `All indices must appear in indexed expressions (e.g., arr[${indexName}]).`,
+                node.location
+              );
+            }
+          }
+        }
+      }
+    }
+
+    const valueType = this.visit(node.value, mappingEnv);
+
+    // Result is an array
+    const rank = node.indices.length;
+    // Result is always an array with the value type as element type
+    const resultType = new ArrayType(valueType, rank);
+
+    env.define(node.target, resultType);
+    env.markImmutable(node.target);
+    return this.setType(node, resultType);
+  },
+
+  /**
+   * Check if an identifier name appears in an expression AST
+   */
+  containsIdentifier(node, name) {
+    if (!node) return false;
+
+    // Check this node
+    if (node.type === "Identifier" && node.name === name) return true;
+
+    // Recursively check children
+    if (node.left && this.containsIdentifier(node.left, name)) return true;
+    if (node.right && this.containsIdentifier(node.right, name)) return true;
+    if (node.operand && this.containsIdentifier(node.operand, name)) return true;
+    if (node.args && node.args.some(arg => this.containsIdentifier(arg, name))) return true;
+    if (node.value && this.containsIdentifier(node.value, name)) return true;
+    if (node.object && this.containsIdentifier(node.object, name)) return true;
+    if (node.property && node.computed && this.containsIdentifier(node.property, name)) return true;
+    if (node.condition && this.containsIdentifier(node.condition, name)) return true;
+    if (node.elements && node.elements.some(el => this.containsIdentifier(el, name))) return true;
+    if (node.bindings && node.bindings.some(b => this.containsIdentifier(b.value, name))) return true;
+    if (node.trailingExpr && this.containsIdentifier(node.trailingExpr, name)) return true;
+    if (node.paths) {
+      for (const path of node.paths) {
+        if (path.condition && this.containsIdentifier(path.condition, name)) return true;
+        if (path.body && path.body.some(stmt => this.containsIdentifier(stmt, name))) return true;
+      }
+    }
+    if (node.callee && this.containsIdentifier(node.callee, name)) return true;
+
+    return false;
+  },
+
+  /**
+   * Find the first array that is indexed by the given variable in an expression.
+   * Mirrors the compiler's search so type errors align with compile-time failures.
+   */
+  findIndexedArray(node, indexVar) {
+    if (!node) return null;
+
+    // Check if this is an indexed access like arr[i]
+    if (node.type === "MemberAccess" && node.computed) {
+      if (node.property?.type === "Identifier" && node.property.name === indexVar) {
+        return node.object;
+      }
+      // Could be nested like obj.field[i], recurse into object
+      const found = this.findIndexedArray(node.object, indexVar);
+      if (found) return found;
+    }
+
+    // Recurse into binary operations
+    if (node.type === "BinaryOp") {
+      const left = this.findIndexedArray(node.left, indexVar);
+      if (left) return left;
+      return this.findIndexedArray(node.right, indexVar);
+    }
+
+    // Recurse into unary operations
+    if (node.type === "UnaryOp") {
+      return this.findIndexedArray(node.operand, indexVar);
+    }
+
+    // Recurse into function calls
+    if (node.type === "FunctionCall") {
+      for (const arg of node.args || []) {
+        const found = this.findIndexedArray(arg, indexVar);
+        if (found) return found;
+      }
+    }
+
+    // Recurse into non-computed member access (e.g., points[i].x)
+    if (node.type === "MemberAccess" && !node.computed) {
+      return this.findIndexedArray(node.object, indexVar);
+    }
+
+    // Recurse into array literals (e.g., [x[i], y[i]])
+    if (node.type === "ArrayLiteral") {
+      for (const elem of node.elements || []) {
+        const found = this.findIndexedArray(elem, indexVar);
+        if (found) return found;
+      }
+    }
+
+    // Recurse into record/object literals
+    if (node.type === "RecordLiteral" || node.type === "ObjectLiteral") {
+      for (const field of node.fields || node.properties || []) {
+        const valueNode = field.value ?? field;
+        const found = this.findIndexedArray(valueNode, indexVar);
+        if (found) return found;
+      }
+    }
+
+    // Recurse into ternary/conditional expressions
+    if (node.type === "ConditionalExpression" || node.type === "TernaryOp") {
+      const found = this.findIndexedArray(node.consequent, indexVar);
+      if (found) return found;
+      return this.findIndexedArray(node.alternate, indexVar);
+    }
+
+    // Recurse into branch expressions (if/elif/else)
+    if (node.type === "BranchExpression") {
+      for (const path of node.paths || []) {
+        if (path.condition) {
+          const found = this.findIndexedArray(path.condition, indexVar);
+          if (found) return found;
+        }
+        for (const stmt of path.body || []) {
+          const found = this.findIndexedArray(stmt, indexVar);
+          if (found) return found;
+        }
+      }
+    }
+
+    return null;
+  },
+
+  /**
+   * Extract chained index accesses from a node, e.g., arr[i][j][k].
+   */
+  extractIndexChain(node, targetIndices) {
+    let current = node;
+    const indices = [];
+
+    while (current && current.type === "MemberAccess" && current.computed) {
+      if (current.property?.type === "Identifier") {
+        const idx = current.property.name;
+        if (targetIndices.includes(idx)) {
+          indices.unshift(idx);
+          current = current.object;
+          continue;
+        }
+      }
+      break;
+    }
+
+    if (indices.length >= 2) {
+      const uniqueIndices = new Set(indices);
+      if (uniqueIndices.size === indices.length) {
+        return { array: current, indices };
+      }
+    }
+
+    return null;
+  },
+
+  /**
+   * Find an N-D indexed array that uses all target indices (supports permutations).
+   */
+  findNDIndexedArray(node, targetIndices) {
+    if (!node) return null;
+
+    const extracted = this.extractIndexChain(node, targetIndices);
+    if (extracted && extracted.indices.length === targetIndices.length) {
+      return extracted;
+    }
+
+    if (node.type === "BinaryOp") {
+      const left = this.findNDIndexedArray(node.left, targetIndices);
+      if (left) return left;
+      return this.findNDIndexedArray(node.right, targetIndices);
+    }
+
+    if (node.type === "UnaryOp") {
+      return this.findNDIndexedArray(node.operand, targetIndices);
+    }
+
+    if (node.type === "FunctionCall") {
+      for (const arg of node.args || []) {
+        const found = this.findNDIndexedArray(arg, targetIndices);
+        if (found) return found;
+      }
+    }
+
+    if (node.type === "MemberAccess" && !node.computed) {
+      return this.findNDIndexedArray(node.object, targetIndices);
+    }
+
+    if (node.type === "ArrayLiteral") {
+      for (const elem of node.elements || []) {
+        const found = this.findNDIndexedArray(elem, targetIndices);
+        if (found) return found;
+      }
+    }
+
+    if (node.type === "RecordLiteral" || node.type === "ObjectLiteral") {
+      for (const field of node.fields || node.properties || []) {
+        const valueNode = field.value ?? field;
+        const found = this.findNDIndexedArray(valueNode, targetIndices);
+        if (found) return found;
+      }
+    }
+
+    if (node.type === "ConditionalExpression" || node.type === "TernaryOp") {
+      const found = this.findNDIndexedArray(node.consequent, targetIndices);
+      if (found) return found;
+      return this.findNDIndexedArray(node.alternate, targetIndices);
+    }
+
+    if (node.type === "BranchExpression") {
+      for (const path of node.paths || []) {
+        if (path.condition) {
+          const found = this.findNDIndexedArray(path.condition, targetIndices);
+          if (found) return found;
+        }
+        for (const stmt of path.body || []) {
+          const found = this.findNDIndexedArray(stmt, targetIndices);
+          if (found) return found;
+        }
+      }
+    }
+
+    return null;
+  },
+
+  /**
+   * Visit a return statement
+   */
+  visitReturnStatement(node, env) {
+    if (node.value) {
+      const valueType = this.visit(node.value, env);
+      return this.setType(node, valueType);
+    }
+    return this.setType(node, UNIT);
+  },
+
+  /**
+   * Visit a member access
+   */
+  visitMemberAccess(node, env) {
+    const objectType = this.visit(node.object, env);
+
+    if (node.computed) {
+      // Array indexing: arr[i]
+      if (objectType instanceof ArrayType) {
+        if (objectType.rank === 1) {
+          return this.setType(node, objectType.elementType);
+        }
+        return this.setType(node, new ArrayType(objectType.elementType, objectType.rank - 1));
+      }
+      return this.setType(node, freshTypeVar());
+    }
+
+    // Property access: obj.field
+    const propName = node.property.name;
+
+    // Array methods - return FunctionType for method calls
+    if (objectType instanceof ArrayType) {
+      // For arrays, the "element" for push is the actual element type (rank 1)
+      // or a sub-array with rank-1 (higher ranks)
+      let pushElemType;
+      if (objectType.rank === 1) {
+        pushElemType = objectType.elementType;
+      } else {
+        // For rank > 1, push accepts sub-array with rank-1
+        pushElemType = new ArrayType(objectType.elementType, objectType.rank - 1);
+      }
+
+      const elemType = objectType.elementType;
+
+      // If element type is unresolved, check for declared type from annotation
+      // This handles: arr: array<num,1> = []  followed by arr.push(x)
+      if (pushElemType instanceof TypeVariable && !pushElemType.resolved) {
+        // Try to get the array variable name for declared type lookup
+        if (node.object && node.object.type === "Identifier") {
+          const arrayVarName = node.object.name;
+          // lookupDeclared already handles primed variables (arr' → arr)
+          const declaredType = env.lookupDeclared(arrayVarName);
+          if (declaredType instanceof ArrayType) {
+            if (objectType.rank === 1) {
+              pushElemType = declaredType.elementType;
+            } else {
+              pushElemType = new ArrayType(declaredType.elementType, objectType.rank - 1);
+            }
+          }
+        }
+      }
+
+      switch (propName) {
+        case 'push':
+          // push(item) -> same container type with item appended
+          return this.setType(node, new FunctionType([pushElemType], objectType));
+        case 'pop':
+          // pop() -> {array: same type, value: elem type}
+          const popResultFields = new Map();
+          popResultFields.set('array', objectType);
+          popResultFields.set('value', elemType);
+          return this.setType(node, new FunctionType([], new RecordType(popResultFields, false)));
+        case 'concat':
+          // concat(other) -> same container type
+          return this.setType(node, new FunctionType([objectType], objectType));
+        case 'slice':
+          // slice(start, end) -> same container type
+          return this.setType(node, new FunctionType([NUM, NUM], objectType));
+        case 'length':
+          // length property
+          return this.setType(node, NUM);
+        default:
+          // Check for imported extension methods
+          const arrayExtension = env.lookupExtension(propName);
+          if (arrayExtension) {
+            // Extension found - return its function type (with self already applied)
+            // The extension's functionType has self as first param, so we return a FunctionType
+            // that expects the remaining params and returns the same return type
+            const extFuncType = arrayExtension.functionType;
+            if (extFuncType instanceof FunctionType) {
+              // Create a function type without the self parameter (already bound to objectType)
+              const remainingParams = extFuncType.paramTypes.slice(1);
+              return this.setType(node, new FunctionType(remainingParams, extFuncType.returnType));
+            }
+            return this.setType(node, freshTypeVar());
+          }
+          // Unknown property/method on array - report error
+          this.addError(
+            `Property '${propName}' does not exist on arrays. Available: push, pop, concat, slice, length`,
+            node.location
+          );
+          return this.setType(node, freshTypeVar());
+      }
+    }
+
+    if (objectType instanceof RecordType) {
+      const fieldType = objectType.fields.get(propName);
+      const recordExtension = env.lookupExtension(propName);
+
+      // Check for conflict: both field and extension exist
+      if (fieldType && recordExtension) {
+        this.addError(
+          `Ambiguous access '${propName}': both an object property and an imported extension method exist. ` +
+          `Use bracket syntax obj["${propName}"] for property access, or ${propName}(obj) for the extension function.`,
+          node.location
+        );
+        return this.setType(node, freshTypeVar());
+      }
+
+      if (fieldType) {
+        // Check if this is a schema record and the field is required (no default)
+        if (objectType.requiredFields && objectType.requiredFields.has(propName)) {
+          this.addError(
+            `Cannot access field '${propName}': it is a required type descriptor with no default value. ` +
+            `Use this schema as a type annotation (e.g., 'x: schemaName = {...}') to create instances.`,
+            node.location
+          );
+          return this.setType(node, freshTypeVar());
+        }
+        return this.setType(node, fieldType);
+      }
+
+      // Check for extension method on object
+      if (recordExtension) {
+        const extFuncType = recordExtension.functionType;
+        if (extFuncType instanceof FunctionType) {
+          const remainingParams = extFuncType.paramTypes.slice(1);
+          return this.setType(node, new FunctionType(remainingParams, extFuncType.returnType));
+        }
+        return this.setType(node, freshTypeVar());
+      }
+
+      // All records are closed - unknown field is an error
+      this.addError(
+        `Field '${propName}' does not exist on record`,
+        node.location
+      );
+      return this.setType(node, freshTypeVar());
+    }
+
+    // Handle field access on TypeVariable - constrain it to be a RecordType
+    // This enables type inference through field access patterns
+    if (objectType instanceof TypeVariable) {
+      const resolved = objectType.resolve();
+      if (resolved !== objectType) {
+        // TypeVariable was resolved - check if it's a RecordType now
+        if (resolved instanceof RecordType) {
+          const fieldType = resolved.fields.get(propName);
+          if (fieldType) {
+            return this.setType(node, fieldType);
+          }
+          // Field not found in resolved record
+          // If the record is open (from inference), extend it with the new field
+          if (resolved.open) {
+            const fieldTypeVar = freshTypeVar();
+            resolved.fields.set(propName, fieldTypeVar);
+            return this.setType(node, fieldTypeVar);
+          }
+          // Closed record - field access error
+          this.addError(
+            `Field '${propName}' does not exist on record`,
+            node.location
+          );
+        }
+        // For other resolved types, fall through
+      } else {
+        // Unresolved TypeVariable - constrain it to be a RecordType with this field
+        // Mark as open so it can be extended with additional fields during inference
+        const fieldTypeVar = freshTypeVar();
+        const fields = new Map();
+        fields.set(propName, fieldTypeVar);
+        const recordConstraint = new RecordType(fields, true); // open = true
+        unify(objectType, recordConstraint);
+        return this.setType(node, fieldTypeVar);
+      }
+    }
+
+    // If we reach here, objectType is a concrete non-record type (num, string, etc.)
+    // Property access on primitives is an error
+    if (objectType instanceof PrimitiveType) {
+      const typeStr = formatType(this.toStructuredType(objectType));
+      this.addError(
+        `Cannot access property '${propName}' on type '${typeStr}'. ` +
+        `Property access is only valid on records.`,
+        node.location
+      );
+    }
+
+    return this.setType(node, freshTypeVar());
+  },
+
+  /**
+   * Visit a range expression
+   */
+  visitRange(node, env) {
+    this.visit(node.start, env);
+    this.visit(node.end, env);
+    if (node.step) {
+      this.visit(node.step, env);
+    }
+    return this.setType(node, new ArrayType(INT, 1));
+  },
+
+  /**
+   * Visit a variable update (loop state transition)
+   */
+  visitVariableUpdate(node, env) {
+    if (node.value) {
+      this.visit(node.value, env);
+    }
+    return this.setType(node, UNIT);
+  },
+};