@xnoxs/flux-lang 3.1.1

package/src/self/linter.js

@@ -0,0 +1,804 @@
+// ── Flux stdlib ──
+
+function sort(arr, fn) { return arr.slice().sort(fn); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.1.0
+"use strict";
+
+const { lexerize } = require("./lexer");
+const { makeParser } = require("./parser");
+const BUILTIN_NAMES = new Set(["self", "this", "arguments", "exports", "module", "require", "__dirname", "__filename", "process", "console", "Math", "JSON", "Object", "Array", "String", "Number", "Boolean", "Promise", "Error", "Symbol", "Map", "Set", "WeakMap", "WeakSet", "Proxy", "Reflect", "undefined", "null", "true", "false", "NaN", "Infinity", "parseInt", "parseFloat", "isNaN", "isFinite", "setTimeout", "clearTimeout", "setInterval", "clearInterval", "fetch", "globalThis", "print", "truncate", "range", "sum", "first", "last", "zip", "flatten", "groupBy", "unique", "sortBy", "chunk"]);
+function isIgnoredName(name) {
+  if (BUILTIN_NAMES.has(name)) {
+    return true;
+  }
+  if (name.startsWith("_")) {
+    return true;
+  }
+  return false;
+}
+class LintIssue {
+  constructor(rule, severity, message, hint, line, col) {
+    this.rule = rule;
+    this.severity = severity;
+    this.message = message;
+    this.hint = hint;
+    this.line = line;
+    this.col = col;
+  }
+
+}
+
+module.exports.LintIssue = LintIssue;
+class LintScope {
+  constructor(parent, kind, vars) {
+    this.parent = parent;
+    this.kind = kind;
+    this.vars = vars;
+  }
+
+  define(name, kind, loc) {
+    const shadowOf = (this.lookupOwn(name) ?? this.lookupParent(name));
+    const entry = { name, kind, loc, used: false, shadowOf };
+    this.vars.set(name, entry);
+    return entry;
+  }
+
+  lookupOwn(name) {
+    return (this.vars.get(name) ?? null);
+  }
+
+  lookupParent(name) {
+    let s = this.parent;
+    while (s) {
+      if (s.vars.has(name)) {
+        return s.vars.get(name);
+      }
+      s = s.parent;
+    }
+    return null;
+  }
+
+  lookup(name) {
+    return (this.lookupOwn(name) ?? this.lookupParent(name));
+  }
+
+  markUsed(name) {
+    const entry = this.lookup(name);
+    if (entry) {
+      entry.used = true;
+    }
+  }
+
+  ownEntries() {
+    return [...this.vars.values()];
+  }
+
+}
+
+module.exports.LintScope = LintScope;
+function makeLintScope(parent, kind) {
+  return new LintScope(parent, kind, new Map());
+}
+function makeLintIssue(rule, severity, message, hint, loc) {
+  const li = new LintIssue(rule, severity, message, null, null, null);
+  li.hint = (hint ?? null);
+  li.line = (loc ? loc.line : null);
+  li.col = (loc ? loc.col : null);
+  return li;
+}
+class Linter {
+  constructor(issues) {
+    this.issues = issues;
+  }
+
+  issue(rule, severity, message, hint, loc) {
+    this.issues.push(makeLintIssue(rule, severity, message, hint, loc));
+  }
+
+  lint(ast) {
+    this.issues = [];
+    const scope = makeLintScope(null, "module");
+    this.walkStmts(ast.body, scope, { inFn: false });
+    return this.issues;
+  }
+
+  isTerminator(node) {
+    if (!node) {
+      return false;
+    }
+    if (((node.type == "ReturnStmt") || (node.type == "ThrowStmt"))) {
+      return true;
+    }
+    if (((node.type == "BreakStmt") || (node.type == "ContinueStmt"))) {
+      return true;
+    }
+    return false;
+  }
+
+  terminatorName(node) {
+    if ((node.type == "ReturnStmt")) {
+      return "return";
+    }
+    if ((node.type == "ThrowStmt")) {
+      return "throw";
+    }
+    if ((node.type == "BreakStmt")) {
+      return "break";
+    }
+    if ((node.type == "ContinueStmt")) {
+      return "continue";
+    }
+    return "terminator";
+  }
+
+  checkUnused(scope) {
+    for (const entry of scope.ownEntries()) {
+      if (entry.used) {
+        continue;
+      }
+      if (isIgnoredName(entry.name)) {
+        continue;
+      }
+      if (entry._exported) {
+        continue;
+      }
+      this.issue("unused-var", "warn", (("'" + entry.name) + "' is declared but never used"), (("Prefix with '_' (e.g. '_" + entry.name) + "') to silence this warning, or remove the declaration"), entry.loc);
+    }
+  }
+
+  walkStmts(stmts, scope, ctx) {
+    if ((!stmts || (stmts.length == 0))) {
+      return;
+    }
+    let i = 0;
+    while ((i < stmts.length)) {
+      const node = stmts[i];
+      if (((i > 0) && this.isTerminator(stmts[(i - 1)]))) {
+        if ((node && node.loc)) {
+          this.issue("unreachable", "error", (("Unreachable code after '" + this.terminatorName(stmts[(i - 1)])) + "'"), "Remove or move the unreachable statement", node.loc);
+          break;
+        }
+      }
+      this.walkStmt(node, scope, ctx);
+      i = (i + 1);
+    }
+    this.checkUnused(scope);
+  }
+
+  walkStmt(node, scope, ctx) {
+    if (!node) {
+      return;
+    }
+    if ((node.type == "VarDecl")) {
+      if (node.init) {
+        this.walkExpr(node.init, scope, ctx);
+      }
+      scope.define(node.name, node.kind, node.loc);
+      return;
+    }
+    if ((node.type == "DestructureDecl")) {
+      if (node.init) {
+        this.walkExpr(node.init, scope, ctx);
+      }
+      if ((node.patternType == "object")) {
+        for (const p of node.pattern) {
+          scope.define((p.alias ?? p.name), node.kind, node.loc);
+        }
+      }
+      else {
+        for (const p of node.pattern) {
+          if (p) {
+            scope.define(p.name, node.kind, node.loc);
+          }
+        }
+      }
+      return;
+    }
+    if ((node.type == "FnDecl")) {
+      if (node.name) {
+        const entry = scope.define(node.name, "val", node.loc);
+        entry.used = true;
+      }
+      const inner = makeLintScope(scope, "fn");
+      for (const p of node.params) {
+        const pe = inner.define(p.name, "val", node.loc);
+        pe.used = true;
+      }
+      if (node.inline) {
+        this.walkExpr(node.body, inner, { ...ctx, inFn: true });
+      }
+      else {
+        this.walkStmts(node.body, inner, { ...ctx, inFn: true });
+      }
+      return;
+    }
+    if ((node.type == "ClassDecl")) {
+      const ce = scope.define(node.name, "val", node.loc);
+      ce.used = true;
+      const cls = makeLintScope(scope, "class");
+      for (const f of (node.fields ?? [])) {
+        const fe = cls.define(f.name, "var", node.loc);
+        fe.used = true;
+      }
+      for (const m of (node.methods ?? [])) {
+        this.walkStmt(m, cls, ctx);
+      }
+      return;
+    }
+    if ((node.type == "TypeDecl")) {
+      for (const v of node.variants) {
+        const ve = scope.define(v.name, "val", node.loc);
+        ve.used = true;
+      }
+      return;
+    }
+    if (((node.type == "InterfaceDecl") || (node.type == "EnumDecl"))) {
+      const ie = scope.define(node.name, "val", node.loc);
+      ie.used = true;
+      return;
+    }
+    if ((node.type == "IfStmt")) {
+      this.walkExpr(node.cond, scope, ctx);
+      const thenScope = makeLintScope(scope, "block");
+      this.walkStmts(node.then, thenScope, ctx);
+      for (const ei of (node.elseifs ?? [])) {
+        this.walkExpr(ei.cond, scope, ctx);
+        const eis = makeLintScope(scope, "block");
+        this.walkStmts(ei.body, eis, ctx);
+      }
+      if (node.else_) {
+        const elseScope = makeLintScope(scope, "block");
+        this.walkStmts(node.else_, elseScope, ctx);
+      }
+      return;
+    }
+    if ((node.type == "ForInStmt")) {
+      this.walkExpr(node.iter, scope, ctx);
+      const forScope = makeLintScope(scope, "block");
+      const loopVar = forScope.define(node.var, "val", node.loc);
+      loopVar.used = true;
+      this.walkStmts(node.body, forScope, { ...ctx, inLoop: true });
+      return;
+    }
+    if ((node.type == "WhileStmt")) {
+      this.walkExpr(node.cond, scope, ctx);
+      const ws = makeLintScope(scope, "block");
+      this.walkStmts(node.body, ws, { ...ctx, inLoop: true });
+      return;
+    }
+    if ((node.type == "DoWhileStmt")) {
+      const ds = makeLintScope(scope, "block");
+      this.walkStmts(node.body, ds, { ...ctx, inLoop: true });
+      this.walkExpr(node.cond, scope, ctx);
+      return;
+    }
+    if ((node.type == "MatchStmt")) {
+      this.walkExpr(node.subject, scope, ctx);
+      for (const arm of node.arms) {
+        const armScope = makeLintScope(scope, "block");
+        if ((arm.pattern && (arm.pattern.type == "VariantPat"))) {
+          for (const b of arm.pattern.bindings) {
+            const be = armScope.define(b, "val", node.loc);
+            be.used = true;
+          }
+        }
+        if (arm.guard) {
+          this.walkExpr(arm.guard, armScope, ctx);
+        }
+        if (arm.inline) {
+          let expr = ((arm.body && arm.body[0]) ? arm.body[0] : null);
+          if (((arm.body && arm.body[0]) && arm.body[0].expr)) {
+            expr = arm.body[0].expr;
+          }
+          if (expr) {
+            this.walkExpr(expr, armScope, ctx);
+          }
+        }
+        else {
+          this.walkStmts((arm.body ?? []), armScope, ctx);
+        }
+      }
+      return;
+    }
+    if ((node.type == "ReturnStmt")) {
+      if (node.value) {
+        this.walkExpr(node.value, scope, ctx);
+      }
+      return;
+    }
+    if ((node.type == "ThrowStmt")) {
+      this.walkExpr(node.value, scope, ctx);
+      return;
+    }
+    if ((node.type == "TryCatchStmt")) {
+      const tryS = makeLintScope(scope, "block");
+      this.walkStmts(node.tryBody, tryS, ctx);
+      if (node.catchBody) {
+        const catchS = makeLintScope(scope, "block");
+        if (node.catchParam) {
+          const ce2 = catchS.define(node.catchParam, "val", node.loc);
+          ce2.used = true;
+        }
+        this.walkStmts(node.catchBody, catchS, ctx);
+      }
+      if (node.finallyBody) {
+        const finS = makeLintScope(scope, "block");
+        this.walkStmts(node.finallyBody, finS, ctx);
+      }
+      return;
+    }
+    if ((node.type == "ImportDecl")) {
+      if (node.defaultName) {
+        const ie2 = scope.define(node.defaultName, "val", node.loc);
+        ie2.used = true;
+      }
+      if (node.namespaceName) {
+        const ne = scope.define(node.namespaceName, "val", node.loc);
+        ne.used = true;
+      }
+      for (const n of (node.names ?? [])) {
+        const nm = ((typeof n == "string") ? n : n.alias);
+        const ie3 = scope.define(nm, "val", node.loc);
+        ie3.used = true;
+      }
+      return;
+    }
+    if ((node.type == "ExportDecl")) {
+      let inner2 = node.decl;
+      if (node.isDefault) {
+        inner2 = { type: "ExprStmt", expr: node.decl };
+      }
+      this.walkStmt(inner2, scope, ctx);
+      if ((node.decl && node.decl.name)) {
+        const ee = scope.lookup(node.decl.name);
+        if (ee) {
+          ee.used = true;
+        }
+        ee._exported = true;
+      }
+      return;
+    }
+    if ((node.type == "ExprStmt")) {
+      this.walkExpr(node.expr, scope, ctx);
+    }
+  }
+
+  walkExpr(node, scope, ctx) {
+    if (!node) {
+      return;
+    }
+    if ((node.type == "Identifier")) {
+      scope.markUsed(node.name);
+      return;
+    }
+    if ((node.type == "AssignExpr")) {
+      this.walkExpr(node.target, scope, ctx);
+      this.walkExpr(node.value, scope, ctx);
+      return;
+    }
+    if ((node.type == "UpdateExpr")) {
+      this.walkExpr(node.operand, scope, ctx);
+      return;
+    }
+    if (((node.type == "BinaryExpr") || (node.type == "PipeExpr"))) {
+      this.walkExpr(node.left, scope, ctx);
+      this.walkExpr(node.right, scope, ctx);
+      return;
+    }
+    if ((((node.type == "UnaryExpr") || (node.type == "AwaitExpr")) || (node.type == "TypeofExpr"))) {
+      this.walkExpr(node.operand, scope, ctx);
+      return;
+    }
+    if ((node.type == "TernaryExpr")) {
+      this.walkExpr(node.cond, scope, ctx);
+      this.walkExpr(node.then, scope, ctx);
+      this.walkExpr(node.else_, scope, ctx);
+      return;
+    }
+    if (((node.type == "CallExpr") || (node.type == "OptCallExpr"))) {
+      this.walkExpr(node.callee, scope, ctx);
+      for (const a of (node.args ?? [])) {
+        this.walkExpr(a, scope, ctx);
+      }
+      return;
+    }
+    if (((node.type == "MemberExpr") || (node.type == "OptMemberExpr"))) {
+      this.walkExpr(node.obj, scope, ctx);
+      return;
+    }
+    if (((node.type == "IndexExpr") || (node.type == "OptIndexExpr"))) {
+      this.walkExpr(node.obj, scope, ctx);
+      this.walkExpr(node.idx, scope, ctx);
+      return;
+    }
+    if ((node.type == "NewExpr")) {
+      if (node.callee) {
+        this.walkExpr(node.callee, scope, ctx);
+      }
+      for (const a of (node.args ?? [])) {
+        this.walkExpr(a, scope, ctx);
+      }
+      return;
+    }
+    if ((node.type == "ArrayExpr")) {
+      for (const itm of (node.items ?? [])) {
+        if (itm) {
+          this.walkExpr(itm, scope, ctx);
+        }
+      }
+      return;
+    }
+    if ((node.type == "ObjectExpr")) {
+      for (const pair of (node.pairs ?? [])) {
+        if (pair.value) {
+          this.walkExpr(pair.value, scope, ctx);
+        }
+      }
+      return;
+    }
+    if ((node.type == "SpreadExpr")) {
+      this.walkExpr(node.expr, scope, ctx);
+      return;
+    }
+    if ((node.type == "LambdaExpr")) {
+      const lInner = makeLintScope(scope, "fn");
+      for (const p of (node.params ?? [])) {
+        const pe = lInner.define(p.name, "val", null);
+        pe.used = true;
+      }
+      this.walkExpr(node.body, lInner, { ...ctx, inFn: true });
+      return;
+    }
+    if ((node.type == "FnDecl")) {
+      if (node.name) {
+        const fentry = scope.define(node.name, "val", node.loc);
+        fentry.used = true;
+      }
+      const fInner = makeLintScope(scope, "fn");
+      for (const p of (node.params ?? [])) {
+        const pe2 = fInner.define(p.name, "val", null);
+        pe2.used = true;
+      }
+      if (node.inline) {
+        this.walkExpr(node.body, fInner, { ...ctx, inFn: true });
+      }
+      else {
+        this.walkStmts(node.body, fInner, { ...ctx, inFn: true });
+      }
+      return;
+    }
+    if ((node.type == "TemplateLit")) {
+      this.walkTemplateParts((node.parts ?? []), scope, ctx);
+      return;
+    }
+    if ((((((node.type == "CastExpr") || (node.type == "AsConstExpr")) || (node.type == "SatisfiesExpr")) || (node.type == "IsExpr")) || (node.type == "NonNullExpr"))) {
+      this.walkExpr(node.expr, scope, ctx);
+      return;
+    }
+    if ((node.type == "RangeExpr")) {
+      this.walkExpr(node.start, scope, ctx);
+      this.walkExpr(node.end, scope, ctx);
+    }
+  }
+
+  walkTemplateParts(parts, scope, ctx) {
+    for (const p of parts) {
+      if ((!p || (p.type != "expr"))) {
+        continue;
+      }
+      try {
+        const tokens = lexerize(p.value).tokenize();
+        const expr = makeParser(tokens).parseExpr();
+        this.walkExpr(expr, scope, ctx);
+      }
+      catch (err3) {
+        const re = /\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
+        let m = re.exec(p.value);
+        while (m) {
+          scope.markUsed(m[1]);
+          m = re.exec(p.value);
+        }
+      }
+    }
+  }
+
+}
+
+module.exports.Linter = Linter;
+class ShadowChecker {
+  constructor(issues) {
+    this.issues = issues;
+  }
+
+  check(ast) {
+    this.issues = [];
+    this.scWalkStmts(ast.body, makeLintScope(null, "module"));
+    return this.issues;
+  }
+
+  scWarn(name, inner, _outer) {
+    this.issues.push(makeLintIssue("shadow-val", "warn", (("'" + name) + "' shadows an outer declaration"), (("Rename one of the '" + name) + "' variables to avoid confusion"), inner));
+  }
+
+  scDefine(scope, name, loc) {
+    const outer = scope.lookupParent(name);
+    if ((outer && !isIgnoredName(name))) {
+      this.scWarn(name, loc, outer.loc);
+    }
+    scope.define(name, "val", loc);
+  }
+
+  scWalkStmts(stmts, scope) {
+    if (!stmts) {
+      return;
+    }
+    for (const node of stmts) {
+      this.scWalkStmt(node, scope);
+    }
+  }
+
+  scWalkStmt(node, scope) {
+    if (!node) {
+      return;
+    }
+    if ((node.type == "VarDecl")) {
+      if (node.init) {
+        this.scWalkExpr(node.init, scope);
+      }
+      this.scDefine(scope, node.name, node.loc);
+      return;
+    }
+    if ((node.type == "DestructureDecl")) {
+      if (node.init) {
+        this.scWalkExpr(node.init, scope);
+      }
+      if ((node.patternType == "object")) {
+        for (const p of node.pattern) {
+          this.scDefine(scope, (p.alias ?? p.name), node.loc);
+        }
+      }
+      else {
+        for (const p of node.pattern) {
+          if (p) {
+            this.scDefine(scope, p.name, node.loc);
+          }
+        }
+      }
+      return;
+    }
+    if ((node.type == "FnDecl")) {
+      if (node.name) {
+        this.scDefine(scope, node.name, node.loc);
+      }
+      const inner = makeLintScope(scope, "fn");
+      for (const p of (node.params ?? [])) {
+        this.scDefine(inner, p.name, node.loc);
+      }
+      if (node.inline) {
+        this.scWalkExpr(node.body, inner);
+      }
+      else {
+        this.scWalkStmts(node.body, inner);
+      }
+      return;
+    }
+    if ((node.type == "ClassDecl")) {
+      this.scDefine(scope, node.name, node.loc);
+      const cls = makeLintScope(scope, "class");
+      for (const m of (node.methods ?? [])) {
+        this.scWalkStmt(m, cls);
+      }
+      return;
+    }
+    if ((node.type == "IfStmt")) {
+      this.scWalkExpr(node.cond, scope);
+      this.scWalkStmts(node.then, makeLintScope(scope, "block"));
+      for (const ei of (node.elseifs ?? [])) {
+        this.scWalkExpr(ei.cond, scope);
+        this.scWalkStmts(ei.body, makeLintScope(scope, "block"));
+      }
+      if (node.else_) {
+        this.scWalkStmts(node.else_, makeLintScope(scope, "block"));
+      }
+      return;
+    }
+    if ((node.type == "ForInStmt")) {
+      this.scWalkExpr(node.iter, scope);
+      const fs2 = makeLintScope(scope, "block");
+      this.scDefine(fs2, node.var, node.loc);
+      this.scWalkStmts(node.body, fs2);
+      return;
+    }
+    if ((node.type == "WhileStmt")) {
+      this.scWalkExpr(node.cond, scope);
+      this.scWalkStmts(node.body, makeLintScope(scope, "block"));
+      return;
+    }
+    if ((node.type == "DoWhileStmt")) {
+      this.scWalkStmts(node.body, makeLintScope(scope, "block"));
+      this.scWalkExpr(node.cond, scope);
+      return;
+    }
+    if ((node.type == "MatchStmt")) {
+      this.scWalkExpr(node.subject, scope);
+      for (const arm of (node.arms ?? [])) {
+        const as2 = makeLintScope(scope, "block");
+        if ((arm.pattern && (arm.pattern.type == "VariantPat"))) {
+          for (const b of arm.pattern.bindings) {
+            this.scDefine(as2, b, node.loc);
+          }
+        }
+        if (arm.guard) {
+          this.scWalkExpr(arm.guard, as2);
+        }
+        if (arm.inline) {
+          let scExpr = ((arm.body && arm.body[0]) ? arm.body[0] : null);
+          if (((arm.body && arm.body[0]) && arm.body[0].expr)) {
+            scExpr = arm.body[0].expr;
+          }
+          if (scExpr) {
+            this.scWalkExpr(scExpr, as2);
+          }
+        }
+        else {
+          this.scWalkStmts((arm.body ?? []), as2);
+        }
+      }
+      return;
+    }
+    if ((node.type == "ReturnStmt")) {
+      if (node.value) {
+        this.scWalkExpr(node.value, scope);
+      }
+      return;
+    }
+    if ((node.type == "ThrowStmt")) {
+      this.scWalkExpr(node.value, scope);
+    }
+    return;
+    if ((node.type == "ExprStmt")) {
+      this.scWalkExpr(node.expr, scope);
+    }
+    return;
+    if ((node.type == "TryCatchStmt")) {
+      this.scWalkStmts(node.tryBody, makeLintScope(scope, "block"));
+      if (node.catchBody) {
+        const cs = makeLintScope(scope, "block");
+        if (node.catchParam) {
+          this.scDefine(cs, node.catchParam, node.loc);
+        }
+        this.scWalkStmts(node.catchBody, cs);
+      }
+      if (node.finallyBody) {
+        this.scWalkStmts(node.finallyBody, makeLintScope(scope, "block"));
+      }
+      return;
+    }
+    if ((node.type == "ImportDecl")) {
+      if (node.defaultName) {
+        this.scDefine(scope, node.defaultName, node.loc);
+      }
+      if (node.namespaceName) {
+        this.scDefine(scope, node.namespaceName, node.loc);
+      }
+      for (const n of (node.names ?? [])) {
+        this.scDefine(scope, ((typeof n == "string") ? n : n.alias), node.loc);
+      }
+      return;
+    }
+    if ((node.type == "ExportDecl")) {
+      this.scWalkStmt((node.isDefault ? { type: "ExprStmt", expr: node.decl } : node.decl), scope);
+    }
+  }
+
+  scWalkExpr(node, scope) {
+    if (!node) {
+      return;
+    }
+    if ((node.type == "LambdaExpr")) {
+      const inner = makeLintScope(scope, "fn");
+      for (const p of (node.params ?? [])) {
+        this.scDefine(inner, p.name, null);
+      }
+      this.scWalkExpr(node.body, inner);
+      return;
+    }
+    if ((node.type == "FnDecl")) {
+      const inner2 = makeLintScope(scope, "fn");
+      for (const p of (node.params ?? [])) {
+        this.scDefine(inner2, p.name, null);
+      }
+      if (node.inline) {
+        this.scWalkExpr(node.body, inner2);
+      }
+      else {
+        this.scWalkStmts(node.body, inner2);
+      }
+      return;
+    }
+    if (((node.type == "BinaryExpr") || (node.type == "PipeExpr"))) {
+      this.scWalkExpr(node.left, scope);
+      this.scWalkExpr(node.right, scope);
+      return;
+    }
+    if ((((((((((node.type == "UnaryExpr") || (node.type == "AwaitExpr")) || (node.type == "TypeofExpr")) || (node.type == "CastExpr")) || (node.type == "AsConstExpr")) || (node.type == "SatisfiesExpr")) || (node.type == "IsExpr")) || (node.type == "NonNullExpr")) || (node.type == "SpreadExpr"))) {
+      this.scWalkExpr((node.operand ?? node.expr), scope);
+      return;
+    }
+    if ((node.type == "TernaryExpr")) {
+      this.scWalkExpr(node.cond, scope);
+      this.scWalkExpr(node.then, scope);
+      this.scWalkExpr(node.else_, scope);
+      return;
+    }
+    if (((node.type == "CallExpr") || (node.type == "OptCallExpr"))) {
+      this.scWalkExpr(node.callee, scope);
+      for (const a of (node.args ?? [])) {
+        this.scWalkExpr(a, scope);
+      }
+      return;
+    }
+    if (((node.type == "MemberExpr") || (node.type == "OptMemberExpr"))) {
+      this.scWalkExpr(node.obj, scope);
+      return;
+    }
+    if (((node.type == "IndexExpr") || (node.type == "OptIndexExpr"))) {
+      this.scWalkExpr(node.obj, scope);
+      this.scWalkExpr(node.idx, scope);
+      return;
+    }
+    if ((node.type == "NewExpr")) {
+      if (node.callee) {
+        this.scWalkExpr(node.callee, scope);
+      }
+      for (const a of (node.args ?? [])) {
+        this.scWalkExpr(a, scope);
+      }
+      return;
+    }
+    if ((node.type == "ArrayExpr")) {
+      for (const itm of (node.items ?? [])) {
+        if (itm) {
+          this.scWalkExpr(itm, scope);
+        }
+      }
+      return;
+    }
+    if ((node.type == "ObjectExpr")) {
+      for (const pair of (node.pairs ?? [])) {
+        if (pair.value) {
+          this.scWalkExpr(pair.value, scope);
+        }
+      }
+      return;
+    }
+    if ((node.type == "AssignExpr")) {
+      this.scWalkExpr(node.target, scope);
+      this.scWalkExpr(node.value, scope);
+      return;
+    }
+    if ((node.type == "UpdateExpr")) {
+      this.scWalkExpr(node.operand, scope);
+      return;
+    }
+    if ((node.type == "RangeExpr")) {
+      this.scWalkExpr(node.start, scope);
+      this.scWalkExpr(node.end, scope);
+    }
+  }
+
+}
+
+module.exports.ShadowChecker = ShadowChecker;
+function lint(ast) {
+  const linter = new Linter([]);
+  const shadowChecker = new ShadowChecker([]);
+  const unusedAndUnreachable = linter.lint(ast);
+  const shadows = shadowChecker.check(ast);
+  const combined = [...unusedAndUnreachable, ...shadows];
+  combined.sort((a, b) => ((a.line ?? 0) - (b.line ?? 0)));
+  return combined;
+}
+module.exports.lint = lint;