@xnoxs/flux-lang 3.1.1

package/src/self/checker.js

@@ -0,0 +1,338 @@
+// Generated by Flux Transpiler v3.1.0
+"use strict";
+
+class CheckError {
+  constructor(message, loc, hint, name, line, col) {
+    this.message = message;
+    this.loc = loc;
+    this.hint = hint;
+    this.name = name;
+    this.line = line;
+    this.col = col;
+  }
+
+}
+
+module.exports.CheckError = CheckError;
+class Scope {
+  constructor(parent, vars) {
+    this.parent = parent;
+    this.vars = vars;
+  }
+
+  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"));
+  }
+
+}
+
+module.exports.Scope = Scope;
+class Checker {
+  constructor(errors, warnings) {
+    this.errors = errors;
+    this.warnings = warnings;
+  }
+
+  error(msg, loc, hint) {
+    const err = new CheckError();
+    err.message = msg;
+    err.loc = loc;
+    err.hint = (hint ?? null);
+    err.name = "CheckError";
+    if (loc) {
+      err.line = loc.line;
+      err.col = loc.col;
+    }
+    this.errors.push(err);
+  }
+
+  warn(msg, loc, hint) {
+    const w = new CheckError();
+    w.message = msg;
+    w.loc = loc;
+    w.hint = (hint ?? null);
+    w.name = "CheckError";
+    if (loc) {
+      w.line = loc.line;
+      w.col = loc.col;
+    }
+    this.warnings.push(w);
+  }
+
+  check(ast) {
+    this.errors = [];
+    this.warnings = [];
+    const scope = new Scope(null, new Map());
+    this.walkStmts(ast.body, scope);
+    return { errors: this.errors, warnings: this.warnings };
+  }
+
+  walkStmts(stmts, scope) {
+    for (const node of stmts) {
+      this.walkStmt(node, scope);
+    }
+  }
+
+  walkStmt(node, scope) {
+    if (!node) {
+      return;
+    }
+    if ((node.type == "VarDecl")) {
+      if (node.init) {
+        this.walkExpr(node.init, scope);
+      }
+      scope.define(node.name, node.kind, node.loc);
+    }
+    else if ((node.type == "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);
+          }
+        }
+      }
+    }
+    else if ((node.type == "FnDecl")) {
+      const inner = new Scope(scope, new Map());
+      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);
+      }
+    }
+    else if ((node.type == "ClassDecl")) {
+      scope.define(node.name, "val", node.loc);
+      const cls = new Scope(scope, new Map());
+      for (const f of node.fields) {
+        cls.define(f.name, "var", node.loc);
+      }
+      for (const m of node.methods) {
+        this.walkStmt(m, cls);
+      }
+    }
+    else if ((node.type == "TypeDecl")) {
+      for (const v of node.variants) {
+        scope.define(v.name, "val", node.loc);
+      }
+    }
+    else if ((node.type == "InterfaceDecl")) {
+      scope.define(node.name, "val", node.loc);
+    }
+    else if ((node.type == "EnumDecl")) {
+      scope.define(node.name, "val", node.loc);
+    }
+    else if ((node.type == "IfStmt")) {
+      this.walkExpr(node.cond, scope);
+      this.walkStmts(node.then, new Scope(scope, new Map()));
+      for (const ei of node.elseifs) {
+        this.walkExpr(ei.cond, scope);
+        this.walkStmts(ei.body, new Scope(scope, new Map()));
+      }
+      if (node.else_) {
+        this.walkStmts(node.else_, new Scope(scope, new Map()));
+      }
+    }
+    else if ((node.type == "ForInStmt")) {
+      this.walkExpr(node.iter, scope);
+      const inner = new Scope(scope, new Map());
+      inner.define(node.var, "val", node.loc);
+      this.walkStmts(node.body, inner);
+    }
+    else if ((node.type == "WhileStmt")) {
+      this.walkExpr(node.cond, scope);
+      this.walkStmts(node.body, new Scope(scope, new Map()));
+    }
+    else if ((node.type == "DoWhileStmt")) {
+      this.walkStmts(node.body, new Scope(scope, new Map()));
+      this.walkExpr(node.cond, scope);
+    }
+    else if ((node.type == "MatchStmt")) {
+      this.walkExpr(node.subject, scope);
+      for (const arm of node.arms) {
+        const inner = new Scope(scope, new Map());
+        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);
+      }
+    }
+    else if ((node.type == "ReturnStmt")) {
+      if (node.value) {
+        this.walkExpr(node.value, scope);
+      }
+    }
+    else if ((node.type == "ThrowStmt")) {
+      this.walkExpr(node.value, scope);
+    }
+    else if ((node.type == "TryCatchStmt")) {
+      this.walkStmts(node.tryBody, new Scope(scope, new Map()));
+      if (node.catchBody) {
+        const inner = new Scope(scope, new Map());
+        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, new Map()));
+      }
+    }
+    else if ((node.type == "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) {
+        const nm = ((typeof n == "string") ? n : n.alias);
+        scope.define(nm, "val", node.loc);
+      }
+    }
+    else if ((node.type == "ExportDecl")) {
+      if (node.isDefault) {
+        this.walkExpr(node.decl, scope);
+      }
+      else {
+        this.walkStmt(node.decl, scope);
+      }
+    }
+    else if ((node.type == "ExprStmt")) {
+      this.walkExpr(node.expr, scope);
+    }
+  }
+
+  walkExpr(node, scope) {
+    if (!node) {
+      return;
+    }
+    if ((node.type == "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);
+    }
+    else if ((node.type == "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);
+    }
+    else if (((node.type == "BinaryExpr") || (node.type == "PipeExpr"))) {
+      this.walkExpr(node.left, scope);
+      this.walkExpr(node.right, scope);
+    }
+    else if ((((node.type == "UnaryExpr") || (node.type == "AwaitExpr")) || (node.type == "TypeofExpr"))) {
+      this.walkExpr(node.operand, scope);
+    }
+    else if ((node.type == "TernaryExpr")) {
+      this.walkExpr(node.cond, scope);
+      this.walkExpr(node.then, scope);
+      this.walkExpr(node.else_, scope);
+    }
+    else if (((node.type == "CallExpr") || (node.type == "OptCallExpr"))) {
+      this.walkExpr(node.callee, scope);
+      for (const a of node.args) {
+        this.walkExpr(a, scope);
+      }
+    }
+    else if (((node.type == "MemberExpr") || (node.type == "OptMemberExpr"))) {
+      this.walkExpr(node.obj, scope);
+    }
+    else if (((node.type == "IndexExpr") || (node.type == "OptIndexExpr"))) {
+      this.walkExpr(node.obj, scope);
+      this.walkExpr(node.idx, scope);
+    }
+    else if ((node.type == "NewExpr")) {
+      for (const a of node.args) {
+        this.walkExpr(a, scope);
+      }
+    }
+    else if ((node.type == "ArrayExpr")) {
+      for (const item of node.items) {
+        if (item) {
+          this.walkExpr(item, scope);
+        }
+      }
+    }
+    else if ((node.type == "ObjectExpr")) {
+      for (const pair of node.pairs) {
+        if (pair.value) {
+          this.walkExpr(pair.value, scope);
+        }
+      }
+    }
+    else if ((node.type == "SpreadExpr")) {
+      this.walkExpr(node.expr, scope);
+    }
+    else if ((node.type == "LambdaExpr")) {
+      const inner = new Scope(scope, new Map());
+      for (const p of node.params) {
+        inner.define(p.name, "val", null);
+      }
+      this.walkExpr(node.body, inner);
+    }
+    else if ((node.type == "FnDecl")) {
+      const inner = new Scope(scope, new Map());
+      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);
+      }
+    }
+    else if ((((((node.type == "CastExpr") || (node.type == "AsConstExpr")) || (node.type == "SatisfiesExpr")) || (node.type == "IsExpr")) || (node.type == "NonNullExpr"))) {
+      this.walkExpr(node.expr, scope);
+    }
+    else if ((node.type == "RangeExpr")) {
+      this.walkExpr(node.start, scope);
+      this.walkExpr(node.end, scope);
+    }
+  }
+
+}
+
+module.exports.Checker = Checker;