@xnoxs/flux-lang 3.2.1 → 3.2.2

package/src/checker.js

@@ -1,322 +0,0 @@
-'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 };