bonescript-compiler 0.2.0

package/src/module_loader.ts

@@ -0,0 +1,114 @@
+/**
+ * BoneScript Module Loader — Resolves import declarations across multiple .bone files.
+ *
+ * Behavior:
+ * - Tracks loaded files to avoid cycles
+ * - Resolves relative paths from importing file
+ * - Merges imported declarations into a single AST
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { Lexer } from "./lexer";
+import { Parser } from "./parser";
+import { RecoveringParser } from "./parser_recovery";
+import { ParseError } from "./parser_base";
+import * as AST from "./ast";
+
+export interface LoadResult {
+  ast: AST.ProgramNode | null;
+  errors: { file: string; error: ParseError }[];
+  loadedFiles: string[];
+}
+
+export class ModuleLoader {
+  private loaded = new Map<string, AST.ProgramNode>();
+  private inProgress = new Set<string>();
+  private errors: { file: string; error: ParseError }[] = [];
+
+  load(entryFile: string): LoadResult {
+    const resolved = path.resolve(entryFile);
+    const ast = this.loadFile(resolved);
+
+    return {
+      ast,
+      errors: this.errors,
+      loadedFiles: Array.from(this.loaded.keys()),
+    };
+  }
+
+  private loadFile(filePath: string): AST.ProgramNode | null {
+    if (this.loaded.has(filePath)) return this.loaded.get(filePath)!;
+    if (this.inProgress.has(filePath)) {
+      this.errors.push({
+        file: filePath,
+        error: new ParseError(`Circular import detected: ${filePath}`, { line: 1, column: 1, offset: 0 }),
+      });
+      return null;
+    }
+
+    if (!fs.existsSync(filePath)) {
+      this.errors.push({
+        file: filePath,
+        error: new ParseError(`File not found: ${filePath}`, { line: 1, column: 1, offset: 0 }),
+      });
+      return null;
+    }
+
+    this.inProgress.add(filePath);
+
+    const source = fs.readFileSync(filePath, "utf-8");
+    const tokens = new Lexer(source).tokenize();
+    const result = new RecoveringParser(tokens).parse();
+
+    for (const err of result.errors) {
+      this.errors.push({ file: filePath, error: err });
+    }
+
+    if (!result.ast) {
+      this.inProgress.delete(filePath);
+      return null;
+    }
+
+    // Resolve imports recursively
+    const importedSystems: AST.SystemDeclNode[] = [];
+    for (const sys of result.ast.systems) {
+      const imports = sys.declarations.filter((d): d is AST.ImportDeclNode => d.kind === "ImportDecl");
+      for (const imp of imports) {
+        const importPath = path.resolve(path.dirname(filePath), imp.from);
+        const importedAst = this.loadFile(importPath);
+        if (importedAst) {
+          importedSystems.push(...importedAst.systems);
+        }
+      }
+    }
+
+    // Merge imported systems' declarations into current systems
+    if (importedSystems.length > 0) {
+      const mergedSystems = result.ast.systems.map(sys => {
+        const importedDecls: AST.DeclarationNode[] = [];
+        for (const imported of importedSystems) {
+          // Add imported entities, events, etc. (skip imports themselves)
+          for (const d of imported.declarations) {
+            if (d.kind !== "ImportDecl") importedDecls.push(d);
+          }
+        }
+        return {
+          ...sys,
+          declarations: [...sys.declarations.filter(d => d.kind !== "ImportDecl"), ...importedDecls],
+        };
+      });
+      result.ast.systems = mergedSystems;
+    } else {
+      // Remove import declarations from final AST
+      result.ast.systems = result.ast.systems.map(sys => ({
+        ...sys,
+        declarations: sys.declarations.filter(d => d.kind !== "ImportDecl"),
+      }));
+    }
+
+    this.loaded.set(filePath, result.ast);
+    this.inProgress.delete(filePath);
+    return result.ast;
+  }
+}

package/src/optimizer.ts

@@ -0,0 +1,196 @@
+/**
+ * BoneScript IR Optimizer — Stage 4.5 (between lowering and codegen).
+ * Implements spec/07_IR_SPEC.md §6 (IR Optimization).
+ *
+ * Passes (applied in order, each idempotent):
+ * 1. Dead module elimination
+ * 2. Store merging (same engine, no conflicting schemas)
+ * 3. Event deduplication
+ * 4. Dependency minimization (remove transitive deps)
+ * 5. Index optimization (remove prefix indexes)
+ */
+
+import * as IR from "./ir";
+
+interface OptimizationLog {
+  pass: string;
+  action: string;
+  target: string;
+}
+
+export interface OptimizationResult {
+  system: IR.IRSystem;
+  log: OptimizationLog[];
+  modulesRemoved: number;
+  eventsDeduped: number;
+  depsRemoved: number;
+}
+
+export function optimize(system: IR.IRSystem): OptimizationResult {
+  const log: OptimizationLog[] = [];
+  let s = system;
+
+  s = deadModuleElimination(s, log);
+  s = storeMerging(s, log);
+  s = eventDeduplication(s, log);
+  s = dependencyMinimization(s, log);
+  s = indexOptimization(s, log);
+
+  return {
+    system: s,
+    log,
+    modulesRemoved: log.filter(l => l.pass === "deadModuleElimination").length,
+    eventsDeduped: log.filter(l => l.pass === "eventDeduplication").length,
+    depsRemoved: log.filter(l => l.pass === "dependencyMinimization").length,
+  };
+}
+
+// ─── Pass 1: Dead Module Elimination ─────────────────────────────────────────
+
+function deadModuleElimination(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const reachable = new Set<string>();
+
+  // Seed: always-reachable kinds
+  for (const m of s.modules) {
+    if (["gateway", "frontend", "auth_service", "api_service", "realtime_service"].includes(m.kind)) {
+      reachable.add(m.id);
+    }
+  }
+
+  // Propagate reachability
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const m of s.modules) {
+      if (reachable.has(m.id)) {
+        for (const dep of m.dependencies) {
+          if (!reachable.has(dep)) {
+            reachable.add(dep);
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+
+  const removed = s.modules.filter(m => !reachable.has(m.id));
+  for (const m of removed) {
+    log.push({ pass: "deadModuleElimination", action: "removed", target: m.name });
+  }
+
+  return { ...s, modules: s.modules.filter(m => reachable.has(m.id)) };
+}
+
+// ─── Pass 2: Store Merging ────────────────────────────────────────────────────
+
+function storeMerging(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const stores = s.modules.filter(m => m.kind === "data_store");
+  const toRemove = new Set<string>();
+  const idRemap = new Map<string, string>();
+
+  for (let i = 0; i < stores.length; i++) {
+    for (let j = i + 1; j < stores.length; j++) {
+      const a = stores[i];
+      const b = stores[j];
+      // Only merge if same engine, both have no models (pure infra stores)
+      if (
+        a.config["engine"] === b.config["engine"] &&
+        a.models.length === 0 &&
+        b.models.length === 0 &&
+        !toRemove.has(a.id)
+      ) {
+        toRemove.add(b.id);
+        idRemap.set(b.id, a.id);
+        log.push({ pass: "storeMerging", action: "merged", target: `${b.name} → ${a.name}` });
+      }
+    }
+  }
+
+  if (toRemove.size === 0) return s;
+
+  const modules = s.modules
+    .filter(m => !toRemove.has(m.id))
+    .map(m => ({
+      ...m,
+      dependencies: [...new Set(m.dependencies.map(d => idRemap.get(d) ?? d))],
+    }));
+
+  return { ...s, modules };
+}
+
+// ─── Pass 3: Event Deduplication ─────────────────────────────────────────────
+
+function eventDeduplication(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const seen = new Set<string>();
+  const events: IR.IREvent[] = [];
+
+  for (const ev of s.events) {
+    if (seen.has(ev.name)) {
+      log.push({ pass: "eventDeduplication", action: "removed duplicate", target: ev.name });
+    } else {
+      seen.add(ev.name);
+      events.push(ev);
+    }
+  }
+
+  return { ...s, events };
+}
+
+// ─── Pass 4: Dependency Minimization ─────────────────────────────────────────
+
+function dependencyMinimization(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const modules = s.modules.map(m => {
+    // Remove self-references and duplicates
+    const original = m.dependencies.length;
+    const deps = [...new Set(m.dependencies.filter(d => d !== m.id))];
+
+    // Remove transitive dependencies: if A→B→C, remove A→C
+    const directDeps = new Set(deps);
+    const transitive = new Set<string>();
+
+    for (const dep of deps) {
+      const depModule = s.modules.find(x => x.id === dep);
+      if (depModule) {
+        for (const transitiveDep of depModule.dependencies) {
+          if (transitiveDep !== m.id) transitive.add(transitiveDep);
+        }
+      }
+    }
+
+    const minimized = deps.filter(d => !transitive.has(d));
+    const removed = original - minimized.length;
+
+    if (removed > 0) {
+      log.push({ pass: "dependencyMinimization", action: `removed ${removed} transitive deps`, target: m.name });
+    }
+
+    return { ...m, dependencies: minimized };
+  });
+
+  return { ...s, modules };
+}
+
+// ─── Pass 5: Index Optimization ──────────────────────────────────────────────
+
+function indexOptimization(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const modules = s.modules.map(m => {
+    const models = m.models.map(model => {
+      // Remove indexes that are prefixes of other indexes
+      const indexes = model.indexes.filter((idx, i) => {
+        const isPrefix = model.indexes.some((other, j) => {
+          if (i === j) return false;
+          if (other.fields.length <= idx.fields.length) return false;
+          return idx.fields.every((f, k) => other.fields[k] === f);
+        });
+        if (isPrefix) {
+          log.push({ pass: "indexOptimization", action: "removed prefix index", target: `${model.name}.${idx.fields.join("_")}` });
+        }
+        return !isPrefix;
+      });
+      return { ...model, indexes };
+    });
+    return { ...m, models };
+  });
+
+  return { ...s, modules };
+}