@xnoxs/flux-lang 3.1.1

package/src/checker.js

@@ -0,0 +1,322 @@
+'use strict';
+
+// ── Flux Static Checker ───────────────────────────────────────────────────────
+// Stage 1: Val immutability analysis (fast, always runs)
+// Stage 2: Full type inference & checking (runs via FluxTypeChecker)
+
+class CheckError {
+  constructor(message, loc, hint = null) {
+    this.message = message;
+    this.loc     = loc;
+    this.hint    = hint;
+    this.name    = 'CheckError';
+    if (loc) { this.line = loc.line; this.col = loc.col; }
+  }
+}
+
+class Scope {
+  constructor(parent = null) {
+    this.parent  = parent;
+    this.vars    = new Map(); // name → { kind:'val'|'var', loc }
+  }
+
+  define(name, kind, loc) { this.vars.set(name, { kind, loc }); }
+
+  lookup(name) {
+    let scope = this;
+    while (scope) {
+      if (scope.vars.has(name)) return scope.vars.get(name);
+      scope = scope.parent;
+    }
+    return null;
+  }
+
+  isVal(name) {
+    const entry = this.lookup(name);
+    return entry && entry.kind === 'val';
+  }
+}
+
+class Checker {
+  constructor() {
+    this.errors   = [];
+    this.warnings = [];
+  }
+
+  check(ast) {
+    this.errors   = [];
+    this.warnings = [];
+    const scope = new Scope();
+    this.walkStmts(ast.body, scope);
+    return { errors: this.errors, warnings: this.warnings };
+  }
+
+  error(msg, loc, hint = null) { this.errors.push(new CheckError(msg, loc, hint)); }
+  warn(msg, loc, hint = null)  { this.warnings.push(new CheckError(msg, loc, hint)); }
+
+  walkStmts(stmts, scope) {
+    for (const node of stmts) this.walkStmt(node, scope);
+  }
+
+  walkStmt(node, scope) {
+    if (!node) return;
+    switch (node.type) {
+      case 'VarDecl':
+        if (node.init) this.walkExpr(node.init, scope);
+        scope.define(node.name, node.kind, node.loc);
+        break;
+
+      case 'DestructureDecl':
+        if (node.init) this.walkExpr(node.init, scope);
+        if (node.patternType === 'object') {
+          for (const p of node.pattern) scope.define(p.alias, node.kind, node.loc);
+        } else {
+          for (const p of node.pattern) { if (p) scope.define(p.name, node.kind, node.loc); }
+        }
+        break;
+
+      case 'FnDecl': {
+        const inner = new Scope(scope);
+        for (const p of node.params) inner.define(p.name, 'val', node.loc);
+        if (node.name) scope.define(node.name, 'val', node.loc);
+        if (node.inline) {
+          this.walkExpr(node.body, inner);
+        } else {
+          this.walkStmts(node.body, inner);
+        }
+        break;
+      }
+
+      case 'ClassDecl': {
+        scope.define(node.name, 'val', node.loc);
+        const cls = new Scope(scope);
+        for (const f of node.fields) cls.define(f.name, 'var', node.loc);
+        for (const m of node.methods) this.walkStmt(m, cls);
+        break;
+      }
+
+      case 'TypeDecl':
+        for (const v of node.variants) scope.define(v.name, 'val', node.loc);
+        break;
+
+      case 'InterfaceDecl':
+        scope.define(node.name, 'val', node.loc);
+        break;
+
+      case 'EnumDecl':
+        scope.define(node.name, 'val', node.loc);
+        break;
+
+      case 'IfStmt':
+        this.walkExpr(node.cond, scope);
+        this.walkStmts(node.then, new Scope(scope));
+        for (const ei of node.elseifs) {
+          this.walkExpr(ei.cond, scope);
+          this.walkStmts(ei.body, new Scope(scope));
+        }
+        if (node.else_) this.walkStmts(node.else_, new Scope(scope));
+        break;
+
+      case 'ForInStmt': {
+        this.walkExpr(node.iter, scope);
+        const inner = new Scope(scope);
+        inner.define(node.var, 'val', node.loc);
+        this.walkStmts(node.body, inner);
+        break;
+      }
+
+      case 'WhileStmt':
+        this.walkExpr(node.cond, scope);
+        this.walkStmts(node.body, new Scope(scope));
+        break;
+
+      case 'DoWhileStmt':
+        this.walkStmts(node.body, new Scope(scope));
+        this.walkExpr(node.cond, scope);
+        break;
+
+      case 'MatchStmt':
+        this.walkExpr(node.subject, scope);
+        for (const arm of node.arms) {
+          const inner = new Scope(scope);
+          if (arm.pattern.type === 'VariantPat') {
+            for (const b of arm.pattern.bindings) inner.define(b, 'val', node.loc);
+          }
+          if (arm.guard) this.walkExpr(arm.guard, inner);
+          this.walkStmts(arm.body, inner);
+        }
+        break;
+
+      case 'ReturnStmt':
+        if (node.value) this.walkExpr(node.value, scope);
+        break;
+
+      case 'ThrowStmt':
+        this.walkExpr(node.value, scope);
+        break;
+
+      case 'TryCatchStmt': {
+        this.walkStmts(node.tryBody, new Scope(scope));
+        if (node.catchBody) {
+          const inner = new Scope(scope);
+          if (node.catchParam) inner.define(node.catchParam, 'val', node.loc);
+          this.walkStmts(node.catchBody, inner);
+        }
+        if (node.finallyBody) this.walkStmts(node.finallyBody, new Scope(scope));
+        break;
+      }
+
+      case 'ImportDecl':
+        if (node.defaultName) scope.define(node.defaultName, 'val', node.loc);
+        if (node.namespaceName) scope.define(node.namespaceName, 'val', node.loc);
+        for (const n of node.names) scope.define(typeof n === 'string' ? n : n.alias, 'val', node.loc);
+        break;
+
+      case 'ExportDecl':
+        this.walkStmt(node.isDefault ? { type: 'ExprStmt', expr: node.decl } : node.decl, scope);
+        break;
+
+      case 'ExprStmt':
+        this.walkExpr(node.expr, scope);
+        break;
+
+      case 'BreakStmt':
+      case 'ContinueStmt':
+        break;
+
+      default:
+        // Unknown node — skip silently
+    }
+  }
+
+  walkExpr(node, scope) {
+    if (!node) return;
+    switch (node.type) {
+
+      case 'AssignExpr': {
+        const target = node.target;
+        if (target.type === 'Identifier') {
+          if (scope.isVal(target.name)) {
+            this.error(
+              `Cannot reassign 'val ${target.name}' — val is immutable`,
+              target.loc,
+              `Use 'var ${target.name}' if you need a mutable variable`
+            );
+          }
+        }
+        this.walkExpr(node.target, scope);
+        this.walkExpr(node.value, scope);
+        break;
+      }
+
+      case 'UpdateExpr':
+        if (node.operand.type === 'Identifier' && scope.isVal(node.operand.name)) {
+          this.error(
+            `Cannot apply '${node.op}' to 'val ${node.operand.name}' — val is immutable`,
+            node.operand.loc,
+            `Use 'var ${node.operand.name}' if you need a mutable variable`
+          );
+        }
+        this.walkExpr(node.operand, scope);
+        break;
+
+      case 'BinaryExpr':
+      case 'PipeExpr':
+        this.walkExpr(node.left,  scope);
+        this.walkExpr(node.right, scope);
+        break;
+
+      case 'UnaryExpr':
+      case 'AwaitExpr':
+      case 'TypeofExpr':
+        this.walkExpr(node.operand, scope);
+        break;
+
+      case 'TernaryExpr':
+        this.walkExpr(node.cond,  scope);
+        this.walkExpr(node.then,  scope);
+        this.walkExpr(node.else_, scope);
+        break;
+
+      case 'CallExpr':
+      case 'OptCallExpr':
+        this.walkExpr(node.callee, scope);
+        for (const a of node.args) this.walkExpr(a, scope);
+        break;
+
+      case 'MemberExpr':
+      case 'OptMemberExpr':
+        this.walkExpr(node.obj, scope);
+        break;
+
+      case 'IndexExpr':
+      case 'OptIndexExpr':
+        this.walkExpr(node.obj, scope);
+        this.walkExpr(node.idx, scope);
+        break;
+
+      case 'NewExpr':
+        for (const a of node.args) this.walkExpr(a, scope);
+        break;
+
+      case 'ArrayExpr':
+        for (const i of node.items) if (i) this.walkExpr(i, scope);
+        break;
+
+      case 'ObjectExpr':
+        for (const p of node.pairs) if (p.value) this.walkExpr(p.value, scope);
+        break;
+
+      case 'SpreadExpr':
+        this.walkExpr(node.expr, scope);
+        break;
+
+      case 'LambdaExpr': {
+        const inner = new Scope(scope);
+        for (const p of node.params) inner.define(p.name, 'val', null);
+        this.walkExpr(node.body, inner);
+        break;
+      }
+
+      case 'FnDecl': {
+        const inner = new Scope(scope);
+        for (const p of node.params) inner.define(p.name, 'val', null);
+        if (node.inline) {
+          this.walkExpr(node.body, inner);
+        } else {
+          this.walkStmts(node.body, inner);
+        }
+        break;
+      }
+
+      case 'TemplateLit':
+        break;
+
+      case 'CastExpr':
+      case 'AsConstExpr':
+      case 'SatisfiesExpr':
+      case 'IsExpr':
+      case 'NonNullExpr':
+        this.walkExpr(node.expr, scope);
+        break;
+
+      case 'RangeExpr':
+        this.walkExpr(node.start, scope);
+        this.walkExpr(node.end,   scope);
+        break;
+
+      case 'Identifier':
+      case 'NumberLit':
+      case 'BoolLit':
+      case 'NullLit':
+      case 'StringLit':
+      case 'SelfExpr':
+        break;
+
+      default:
+        // Unknown expression node — skip
+    }
+  }
+}
+
+module.exports = { Checker };