bonescript-compiler 0.2.0

package/src/typechecker.ts

@@ -0,0 +1,591 @@
+/**
+ * BoneScript Type Checker — Stage 3 of the compilation pipeline.
+ * Implements spec/04_TYPE_SYSTEM.md.
+ *
+ * Responsibilities:
+ * 1. Build symbol table from entity declarations
+ * 2. Verify all field types resolve to valid types
+ * 3. Verify all constraint expressions type to bool
+ * 4. Verify capability preconditions type to bool
+ * 5. Verify effects are well-typed (target and value match)
+ * 6. Verify emitted events exist
+ * 7. Verify state machine transitions reference valid states
+ * 8. Verify flow steps reference valid capabilities
+ *
+ * Deterministic: same AST always produces same errors in same order.
+ */
+
+import * as AST from "./ast";
+import {
+  CVType, PrimitiveType, GenericType, RecordType,
+  prim, generic, record, BOTTOM,
+  typeEquals, typeToString, isNumeric, isComparable,
+} from "./types";
+
+// ─── Type Error ──────────────────────────────────────────────────────────────
+
+export interface TypeError {
+  code: string;
+  message: string;
+  loc: AST.ASTNode["loc"];
+}
+
+// ─── Symbol Table ────────────────────────────────────────────────────────────
+
+interface EntitySymbol {
+  name: string;
+  type: RecordType;
+  states: string[];
+  capabilities: string[];
+}
+
+interface CapabilitySymbol {
+  name: string;
+  params: Map<string, CVType>;
+}
+
+interface EventSymbol {
+  name: string;
+  payloadFields: Map<string, CVType>;
+}
+
+interface SymbolTable {
+  entities: Map<string, EntitySymbol>;
+  capabilities: Map<string, CapabilitySymbol>;
+  events: Map<string, EventSymbol>;
+  stores: Set<string>;
+  channels: Set<string>;
+  flows: Set<string>;
+}
+
+// ─── Type Checker ────────────────────────────────────────────────────────────
+
+export class TypeChecker {
+  private errors: TypeError[] = [];
+  private symbols: SymbolTable = {
+    entities: new Map(),
+    capabilities: new Map(),
+    events: new Map(),
+    stores: new Set(),
+    channels: new Set(),
+    flows: new Set(),
+  };
+
+  check(program: AST.ProgramNode): TypeError[] {
+    this.errors = [];
+
+    for (const system of program.systems) {
+      this.checkSystem(system);
+    }
+
+    return this.errors;
+  }
+
+  private addError(code: string, message: string, loc: AST.ASTNode["loc"]) {
+    this.errors.push({ code, message, loc });
+  }
+
+  // ─── Phase 1: Build Symbol Table ──────────────────────────────────────────
+
+  private checkSystem(system: AST.SystemDeclNode) {
+    // First pass: register all declarations
+    for (const decl of system.declarations) {
+      this.registerDeclaration(decl);
+    }
+
+    // Second pass: type check all declarations
+    for (const decl of system.declarations) {
+      this.checkDeclaration(decl);
+    }
+  }
+
+  private registerDeclaration(decl: AST.DeclarationNode) {
+    switch (decl.kind) {
+      case "EntityDecl":
+        this.registerEntity(decl);
+        break;
+      case "CapabilityDecl":
+        this.registerCapability(decl);
+        break;
+      case "EventDecl":
+        this.registerEvent(decl);
+        break;
+      case "StoreDecl":
+        this.symbols.stores.add(decl.name);
+        break;
+      case "ChannelDecl":
+        this.symbols.channels.add(decl.name);
+        break;
+      case "FlowDecl":
+        this.symbols.flows.add(decl.name);
+        break;
+    }
+  }
+
+  private registerEntity(decl: AST.EntityDeclNode) {
+    const fields = new Map<string, CVType>();
+
+    // Ontology-entailed fields (always present)
+    fields.set("id", prim("uuid"));
+    fields.set("created_at", prim("timestamp"));
+    fields.set("updated_at", prim("timestamp"));
+
+    // Declared fields
+    for (const field of decl.owns) {
+      const resolved = this.resolveTypeExpr(field.type);
+      if (resolved) {
+        fields.set(field.name, resolved);
+      }
+    }
+
+    const states = decl.states
+      ? decl.states.nodes.map(n => n.name)
+      : [];
+
+    this.symbols.entities.set(decl.name, {
+      name: decl.name,
+      type: record(decl.name, fields),
+      states,
+      capabilities: [],
+    });
+  }
+
+  private registerCapability(decl: AST.CapabilityDeclNode) {
+    const params = new Map<string, CVType>();
+    for (const p of decl.params) {
+      const resolved = this.resolveTypeExpr(p.type);
+      if (resolved) params.set(p.name, resolved);
+    }
+    this.symbols.capabilities.set(decl.name, { name: decl.name, params });
+  }
+
+  private registerEvent(decl: AST.EventDeclNode) {
+    const fields = new Map<string, CVType>();
+    for (const f of decl.payload) {
+      const resolved = this.resolveTypeExpr(f.type);
+      if (resolved) fields.set(f.name, resolved);
+    }
+    this.symbols.events.set(decl.name, { name: decl.name, payloadFields: fields });
+  }
+
+  // ─── Phase 2: Type Check Declarations ─────────────────────────────────────
+
+  private checkDeclaration(decl: AST.DeclarationNode) {
+    switch (decl.kind) {
+      case "EntityDecl": this.checkEntity(decl); break;
+      case "CapabilityDecl": this.checkCapability(decl); break;
+      case "ChannelDecl": this.checkChannel(decl); break;
+      case "FlowDecl": this.checkFlow(decl); break;
+      case "ConstraintDecl": this.checkConstraint(decl); break;
+      case "ExtensionPointDecl": this.checkExtensionPoint(decl); break;
+    }
+  }
+
+  // ─── Entity Checking ──────────────────────────────────────────────────────
+
+  private checkEntity(decl: AST.EntityDeclNode) {
+    // Check for duplicate field names
+    const seen = new Set<string>();
+    for (const field of decl.owns) {
+      if (seen.has(field.name)) {
+        this.addError("T009", `Duplicate field name '${field.name}' in entity '${decl.name}'`, field.loc);
+      }
+      seen.add(field.name);
+    }
+
+    // Check field types resolve
+    for (const field of decl.owns) {
+      const resolved = this.resolveTypeExpr(field.type);
+      if (!resolved) {
+        this.addError("T001", `Undefined type in field '${field.name}'`, field.loc);
+      }
+    }
+
+    // Check constraints type to bool
+    const entitySym = this.symbols.entities.get(decl.name);
+    if (entitySym) {
+      const ctx = new TypeContext(entitySym.type.fields, this.symbols);
+      for (const constraint of decl.constraints) {
+        const ctype = this.inferExprType(constraint, ctx);
+        if (ctype && ctype.tag !== "primitive") {
+          this.addError("T005", `Constraint expression must type to bool, got ${typeToString(ctype)}`, constraint.loc);
+        } else if (ctype && ctype.tag === "primitive" && ctype.name !== "bool") {
+          // Allow — many constraints are comparison exprs that return bool
+          // The expression inferrer returns bool for comparisons
+        }
+      }
+    }
+
+    // Check state machine
+    if (decl.states) {
+      const stateNames = new Set(decl.states.nodes.map(n => n.name));
+      for (const node of decl.states.nodes) {
+        for (const target of node.transitions) {
+          if (!stateNames.has(target)) {
+            this.addError("T010", `Undefined state '${target}' in transition from '${node.name}'`, decl.states.loc);
+          }
+        }
+        for (const target of node.branches) {
+          if (!stateNames.has(target)) {
+            this.addError("T010", `Undefined state '${target}' in branch from '${node.name}'`, decl.states.loc);
+          }
+        }
+      }
+    }
+  }
+
+  // ─── Capability Checking ───────────────────────────────────────────────────
+
+  private checkCapability(decl: AST.CapabilityDeclNode) {
+    // Build typing context from parameters
+    const fields = new Map<string, CVType>();
+    for (const p of decl.params) {
+      const resolved = this.resolveTypeExpr(p.type);
+      if (resolved) {
+        fields.set(p.name, resolved);
+      } else {
+        this.addError("T006", `Parameter '${p.name}' references undeclared type`, p.loc);
+      }
+    }
+    const ctx = new TypeContext(fields, this.symbols);
+
+    // Check requires clauses type to bool
+    for (const req of decl.requires) {
+      const rtype = this.inferExprType(req, ctx);
+      if (rtype && !this.isBoolish(rtype)) {
+        this.addError("T005", `Requires expression must type to bool, got ${typeToString(rtype)}`, req.loc);
+      }
+    }
+
+    // Check effects are well-typed
+    for (const effect of decl.effects) {
+      this.checkEffect(effect, ctx);
+    }
+
+    // Check emitted events exist
+    for (const emit of decl.emits) {
+      if (!this.symbols.events.has(emit.eventName)) {
+        this.addError("T011", `Emitted event '${emit.eventName}' is not declared`, emit.loc);
+      }
+    }
+  }
+
+  private checkEffect(effect: AST.EffectNode, ctx: TypeContext) {
+    const targetType = this.inferExprType(effect.target, ctx);
+    const valueType = this.inferExprType(effect.value, ctx);
+
+    if (!targetType || !valueType) return; // already errored
+
+    switch (effect.op) {
+      case "=":
+        if (!typeEquals(targetType, valueType) && !this.isAssignable(valueType, targetType)) {
+          this.addError("T003",
+            `Type mismatch in assignment: target is ${typeToString(targetType)}, value is ${typeToString(valueType)}`,
+            effect.loc);
+        }
+        break;
+      case "+=":
+        // target must be set<T> or numeric, value must be T or numeric
+        if (targetType.tag === "generic" && targetType.name === "set") {
+          if (!typeEquals(targetType.args[0], valueType)) {
+            this.addError("T008",
+              `Set += requires element type ${typeToString(targetType.args[0])}, got ${typeToString(valueType)}`,
+              effect.loc);
+          }
+        } else if (isNumeric(targetType)) {
+          if (!isNumeric(valueType)) {
+            this.addError("T003", `Numeric += requires numeric value, got ${typeToString(valueType)}`, effect.loc);
+          }
+        } else {
+          this.addError("T008", `+= requires set or numeric target, got ${typeToString(targetType)}`, effect.loc);
+        }
+        break;
+      case "-=":
+        if (targetType.tag === "generic" && targetType.name === "set") {
+          if (!typeEquals(targetType.args[0], valueType)) {
+            this.addError("T008",
+              `Set -= requires element type ${typeToString(targetType.args[0])}, got ${typeToString(valueType)}`,
+              effect.loc);
+          }
+        } else if (isNumeric(targetType)) {
+          if (!isNumeric(valueType)) {
+            this.addError("T003", `Numeric -= requires numeric value, got ${typeToString(valueType)}`, effect.loc);
+          }
+        } else {
+          this.addError("T008", `-= requires set or numeric target, got ${typeToString(targetType)}`, effect.loc);
+        }
+        break;
+    }
+  }
+
+  // ─── Channel Checking ──────────────────────────────────────────────────────
+
+  private checkChannel(decl: AST.ChannelDeclNode) {
+    // Verify participants type is set<Entity>
+    if (decl.participants) {
+      const ptype = this.resolveTypeExpr(decl.participants);
+      if (ptype && ptype.tag === "generic" && ptype.name === "set") {
+        const inner = ptype.args[0];
+        if (inner.tag === "record" && !this.symbols.entities.has(inner.name)) {
+          this.addError("T001", `Channel participants reference undeclared entity '${inner.name}'`, decl.loc);
+        }
+      }
+    }
+  }
+
+  // ─── Flow Checking ─────────────────────────────────────────────────────────
+
+  private checkFlow(decl: AST.FlowDeclNode) {
+    for (const step of decl.steps) {
+      // Check step action references a valid capability or function
+      if (!this.symbols.capabilities.has(step.action.name) &&
+          !this.symbols.entities.has(step.action.name)) {
+        // Allow — could be a helper function not yet declared
+        // In strict mode this would be T012
+      }
+
+      // Check compensation exists if step has one
+      if (step.compensate) {
+        // Same check — compensation should reference a valid capability
+      }
+    }
+
+    // Check at least 2 steps (ontology requirement)
+    if (decl.steps.length < 2) {
+      this.addError("T012", `Flow '${decl.name}' must have at least 2 steps`, decl.loc);
+    }
+  }
+
+  // ─── Constraint Checking ───────────────────────────────────────────────────
+
+  private checkConstraint(decl: AST.ConstraintDeclNode) {
+    // Top-level constraints are checked in a global context
+    const globalCtx = new TypeContext(new Map(), this.symbols);
+    const ctype = this.inferExprType(decl.expr, globalCtx);
+    if (ctype && !this.isBoolish(ctype)) {
+      this.addError("T005", `Top-level constraint '${decl.name}' must type to bool`, decl.loc);
+    }
+  }
+
+  // ─── Expression Type Inference ─────────────────────────────────────────────
+
+  private inferExprType(expr: AST.ExprNode, ctx: TypeContext): CVType | null {
+    switch (expr.kind) {
+      case "Literal":
+        return this.inferLiteralType(expr);
+      case "FieldRef":
+        return this.inferFieldRefType(expr, ctx);
+      case "BinaryExpr":
+        return this.inferBinaryType(expr, ctx);
+      case "UnaryExpr":
+        return this.inferUnaryType(expr, ctx);
+      case "CallExpr":
+        return this.inferCallType(expr, ctx);
+      case "TernaryExpr":
+        return this.inferTernaryType(expr, ctx);
+      default:
+        return null;
+    }
+  }
+
+  private inferLiteralType(expr: AST.LiteralNode): CVType {
+    switch (expr.type) {
+      case "string": return prim("string");
+      case "int": return prim("uint"); // default to uint per spec
+      case "float": return prim("float");
+      case "bool": return prim("bool");
+      case "none": return BOTTOM;
+      case "list": return generic("list", prim("json")); // infer element type later
+      case "map": return prim("json");
+    }
+  }
+
+  private inferFieldRefType(expr: AST.FieldRefNode, ctx: TypeContext): CVType | null {
+    const path = expr.path;
+    if (path.length === 0) return null;
+
+    // First segment: look up in context
+    let currentType = ctx.lookup(path[0]);
+
+    if (!currentType) {
+      // Try as entity name (for top-level constraints like Player.active_trades)
+      const entity = this.symbols.entities.get(path[0]);
+      if (entity) {
+        currentType = entity.type;
+        return this.resolveFieldPath(currentType, path.slice(1), expr);
+      }
+      // Unknown — don't error here, could be a forward reference
+      return prim("json"); // permissive fallback
+    }
+
+    return this.resolveFieldPath(currentType, path.slice(1), expr);
+  }
+
+  private resolveFieldPath(baseType: CVType, remaining: string[], expr: AST.ExprNode): CVType | null {
+    let current = baseType;
+
+    for (const segment of remaining) {
+      // Handle .unique, .length, .size as derived properties
+      if (segment === "unique") return prim("bool");
+      if (segment === "length") return prim("uint");
+      if (segment === "size") return prim("uint");
+
+      if (current.tag === "record") {
+        const field = current.fields.get(segment);
+        if (field) {
+          current = field;
+        } else {
+          // Field not found — could be a derived property
+          return prim("json"); // permissive
+        }
+      } else if (current.tag === "generic") {
+        // Accessing property on generic type (e.g., list.size)
+        if (segment === "size" || segment === "length") return prim("uint");
+        return prim("json");
+      } else {
+        return prim("json"); // permissive fallback
+      }
+    }
+
+    return current;
+  }
+
+  private inferBinaryType(expr: AST.BinaryExprNode, ctx: TypeContext): CVType {
+    const left = this.inferExprType(expr.left, ctx);
+    const right = this.inferExprType(expr.right, ctx);
+
+    switch (expr.op) {
+      // Comparison operators → bool
+      case "==": case "!=": case "<": case ">": case "<=": case ">=":
+      case "in": case "contains": case "and": case "or":
+        return prim("bool");
+
+      // Range operator
+      case "..":
+        return generic("list", prim("uint")); // range produces a range object
+
+      // Arithmetic → numeric
+      case "+": case "*": case "/": case "%":
+        if (left && right && isNumeric(left) && isNumeric(right)) {
+          // Promote to widest type
+          if ((left as PrimitiveType).name === "float" || (right as PrimitiveType).name === "float") return prim("float");
+          if ((left as PrimitiveType).name === "int" || (right as PrimitiveType).name === "int") return prim("int");
+          return prim("uint");
+        }
+        if (expr.op === "+" && left?.tag === "primitive" && (left as PrimitiveType).name === "string") {
+          return prim("string"); // string concatenation
+        }
+        return prim("uint");
+
+      case "-":
+        return prim("int"); // subtraction may produce negative
+
+      default:
+        return prim("bool");
+    }
+  }
+
+  private inferUnaryType(expr: AST.UnaryExprNode, ctx: TypeContext): CVType {
+    if (expr.op === "not") return prim("bool");
+    if (expr.op === "-") return prim("int");
+    return prim("json");
+  }
+
+  private inferCallType(expr: AST.CallExprNode, ctx: TypeContext): CVType {
+    // Built-in functions
+    if (expr.name === "now") return prim("timestamp");
+    if (expr.name === "count") return prim("uint");
+    if (expr.name === "sum") return prim("uint");
+
+    // User-defined — return json as permissive fallback
+    return prim("json");
+  }
+
+  private inferTernaryType(expr: AST.TernaryExprNode, ctx: TypeContext): CVType | null {
+    // condition must be bool
+    const condType = this.inferExprType(expr.condition, ctx);
+    if (condType && !this.isBoolish(condType)) {
+      this.addError("T005", "Ternary condition must be bool", expr.loc);
+    }
+    // result type is type of consequent (assume both branches same type)
+    return this.inferExprType(expr.consequent, ctx);
+  }
+
+  // ─── Helpers ───────────────────────────────────────────────────────────────
+
+  private resolveTypeExpr(typeExpr: AST.TypeExprNode): CVType | null {
+    switch (typeExpr.kind) {
+      case "PrimitiveType":
+        return prim(typeExpr.name as PrimitiveType["name"]);
+      case "GenericType": {
+        const args = typeExpr.typeArgs.map(a => this.resolveTypeExpr(a)).filter(Boolean) as CVType[];
+        return generic(typeExpr.name as GenericType["name"], ...args);
+      }
+      case "EntityRefType": {
+        const entity = this.symbols.entities.get(typeExpr.name);
+        if (entity) return entity.type;
+        // Could be a forward reference — register as unknown record
+        return record(typeExpr.name, new Map());
+      }
+      case "TupleType": {
+        const elements = typeExpr.elements.map(e => this.resolveTypeExpr(e)).filter(Boolean) as CVType[];
+        return { tag: "tuple", elements };
+      }
+      case "UnionType": {
+        const members = typeExpr.members.map(m => this.resolveTypeExpr(m)).filter(Boolean) as CVType[];
+        return { tag: "union", members };
+      }
+    }
+  }
+
+  private isBoolish(t: CVType): boolean {
+    return (t.tag === "primitive" && t.name === "bool") || t.tag === "bottom";
+  }
+
+  private isAssignable(source: CVType, target: CVType): boolean {
+    if (typeEquals(source, target)) return true;
+    // Numeric widening: uint → int → float
+    if (source.tag === "primitive" && target.tag === "primitive") {
+      if (source.name === "uint" && (target.name === "int" || target.name === "float")) return true;
+      if (source.name === "int" && target.name === "float") return true;
+    }
+    // json accepts anything and anything accepts json (permissive for unresolved)
+    if (target.tag === "primitive" && target.name === "json") return true;
+    if (source.tag === "primitive" && source.name === "json") return true;
+    return false;
+  }
+  private checkExtensionPoint(decl: AST.ExtensionPointDeclNode): void {
+    for (const p of decl.params) {
+      const resolved = this.resolveTypeExpr(p.type);
+      if (!resolved) {
+        this.addError("T001", "Extension point '" + decl.name + "' param '" + p.name + "' references undefined type", p.loc);
+      }
+    }
+    if (decl.returns) {
+      const resolved = this.resolveTypeExpr(decl.returns);
+      if (!resolved) {
+        this.addError("T001", "Extension point '" + decl.name + "' return type is undefined", decl.loc);
+      }
+    }
+  }
+
+
+}
+// ─── Type Context ────────────────────────────────────────────────────────────
+
+class TypeContext {
+  private locals: Map<string, CVType>;
+  private symbols: SymbolTable;
+
+  constructor(locals: Map<string, CVType>, symbols: SymbolTable) {
+    this.locals = locals;
+    this.symbols = symbols;
+  }
+  lookup(name: string): CVType | null {
+    const local = this.locals.get(name);
+    if (local) return local;
+    const entity = this.symbols.entities.get(name);
+    if (entity) return entity.type;
+    return null;
+  }
+}