@xnoxs/flux-lang 3.1.1

package/src/self/linter.flux

@@ -0,0 +1,515 @@
+// ============================================================
+//  Flux Self-Hosted Linter
+//  src/self/linter.flux — written in Flux, compiled by stage-0
+//
+//  AST-level lint rules:
+//    RULE 1 — unused-var   : val/var declared but never read
+//    RULE 2 — unreachable  : code after return/throw/break/continue
+//    RULE 3 — shadow-val   : inner val/var shadows outer binding
+// ============================================================
+
+import { lexerize }   from './lexer'
+import { makeParser } from './parser'
+
+val 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',
+])
+
+fn isIgnoredName(name):
+  if BUILTIN_NAMES.has(name): return true
+  if name.startsWith('_'):    return true
+  return false
+
+// ── LintIssue ────────────────────────────────────────────────
+export class LintIssue:
+  rule:     string
+  severity: string
+  message:  string
+  hint:     any
+  line:     any
+  col:      any
+
+// ── LintScope ────────────────────────────────────────────────
+export class LintScope:
+  parent: any
+  kind:   string
+  vars:   any
+
+  fn define(name, kind, loc):
+    val shadowOf = self.lookupOwn(name) ?? self.lookupParent(name)
+    val entry = { name, kind, loc, used: false, shadowOf }
+    self.vars.set(name, entry)
+    return entry
+
+  fn lookupOwn(name):
+    return self.vars.get(name) ?? null
+
+  fn lookupParent(name):
+    var s = self.parent
+    while s:
+      if s.vars.has(name): return s.vars.get(name)
+      s = s.parent
+    return null
+
+  fn lookup(name):
+    return self.lookupOwn(name) ?? self.lookupParent(name)
+
+  fn markUsed(name):
+    val entry = self.lookup(name)
+    if entry: entry.used = true
+
+  fn ownEntries():
+    return [...self.vars.values()]
+
+fn makeLintScope(parent, kind):
+  return new LintScope(parent, kind, new Map())
+
+fn makeLintIssue(rule, severity, message, hint, loc):
+  val 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
+
+// ── Linter ───────────────────────────────────────────────────
+export class Linter:
+  issues: any[]
+
+  fn issue(rule, severity, message, hint, loc):
+    self.issues.push(makeLintIssue(rule, severity, message, hint, loc))
+
+  fn lint(ast):
+    self.issues = []
+    val scope = makeLintScope(null, 'module')
+    self.walkStmts(ast.body, scope, { inFn: false })
+    return self.issues
+
+  fn isTerminator(node):
+    if not node: return false
+    if node.type == 'ReturnStmt' or node.type == 'ThrowStmt': return true
+    if node.type == 'BreakStmt'  or node.type == 'ContinueStmt': return true
+    return false
+
+  fn 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'
+
+  fn checkUnused(scope):
+    for entry in scope.ownEntries():
+      if entry.used:               continue
+      if isIgnoredName(entry.name): continue
+      if entry._exported:          continue
+      self.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)
+
+  fn walkStmts(stmts, scope, ctx):
+    if not stmts or stmts.length == 0: return
+    var i = 0
+    while i < stmts.length:
+      val node = stmts[i]
+      if i > 0 and self.isTerminator(stmts[i - 1]):
+        if node and node.loc:
+          self.issue('unreachable', 'error',
+            "Unreachable code after '" + self.terminatorName(stmts[i - 1]) + "'",
+            'Remove or move the unreachable statement', node.loc)
+          break
+      self.walkStmt(node, scope, ctx)
+      i = i + 1
+    self.checkUnused(scope)
+
+  fn walkStmt(node, scope, ctx):
+    if not node: return
+    if node.type == 'VarDecl':
+      if node.init: self.walkExpr(node.init, scope, ctx)
+      scope.define(node.name, node.kind, node.loc)
+      return
+    if node.type == 'DestructureDecl':
+      if node.init: self.walkExpr(node.init, scope, ctx)
+      if node.patternType == 'object':
+        for p in node.pattern: scope.define(p.alias ?? p.name, node.kind, node.loc)
+      else:
+        for p in node.pattern: if p: scope.define(p.name, node.kind, node.loc)
+      return
+    if node.type == 'FnDecl':
+      if node.name:
+        val entry = scope.define(node.name, 'val', node.loc)
+        entry.used = true
+      val inner = makeLintScope(scope, 'fn')
+      for p in node.params:
+        val pe = inner.define(p.name, 'val', node.loc)
+        pe.used = true
+      if node.inline:
+        self.walkExpr(node.body, inner, { ...ctx, inFn: true })
+      else:
+        self.walkStmts(node.body, inner, { ...ctx, inFn: true })
+      return
+    if node.type == 'ClassDecl':
+      val ce = scope.define(node.name, 'val', node.loc)
+      ce.used = true
+      val cls = makeLintScope(scope, 'class')
+      for f in (node.fields ?? []):
+        val fe = cls.define(f.name, 'var', node.loc)
+        fe.used = true
+      for m in (node.methods ?? []): self.walkStmt(m, cls, ctx)
+      return
+    if node.type == 'TypeDecl':
+      for v in node.variants:
+        val ve = scope.define(v.name, 'val', node.loc)
+        ve.used = true
+      return
+    if node.type == 'InterfaceDecl' or node.type == 'EnumDecl':
+      val ie = scope.define(node.name, 'val', node.loc)
+      ie.used = true
+      return
+    if node.type == 'IfStmt':
+      self.walkExpr(node.cond, scope, ctx)
+      val thenScope = makeLintScope(scope, 'block')
+      self.walkStmts(node.then, thenScope, ctx)
+      for ei in (node.elseifs ?? []):
+        self.walkExpr(ei.cond, scope, ctx)
+        val eis = makeLintScope(scope, 'block')
+        self.walkStmts(ei.body, eis, ctx)
+      if node.else_:
+        val elseScope = makeLintScope(scope, 'block')
+        self.walkStmts(node.else_, elseScope, ctx)
+      return
+    if node.type == 'ForInStmt':
+      self.walkExpr(node.iter, scope, ctx)
+      val forScope = makeLintScope(scope, 'block')
+      val loopVar  = forScope.define(node.var, 'val', node.loc)
+      loopVar.used = true
+      self.walkStmts(node.body, forScope, { ...ctx, inLoop: true })
+      return
+    if node.type == 'WhileStmt':
+      self.walkExpr(node.cond, scope, ctx)
+      val ws = makeLintScope(scope, 'block')
+      self.walkStmts(node.body, ws, { ...ctx, inLoop: true })
+      return
+    if node.type == 'DoWhileStmt':
+      val ds = makeLintScope(scope, 'block')
+      self.walkStmts(node.body, ds, { ...ctx, inLoop: true })
+      self.walkExpr(node.cond, scope, ctx)
+      return
+    if node.type == 'MatchStmt':
+      self.walkExpr(node.subject, scope, ctx)
+      for arm in node.arms:
+        val armScope = makeLintScope(scope, 'block')
+        if arm.pattern and arm.pattern.type == 'VariantPat':
+          for b in arm.pattern.bindings:
+            val be = armScope.define(b, 'val', node.loc)
+            be.used = true
+        if arm.guard: self.walkExpr(arm.guard, armScope, ctx)
+        if arm.inline:
+          var expr = arm.body and arm.body[0] ? arm.body[0] : null
+          if arm.body and arm.body[0] and arm.body[0].expr: expr = arm.body[0].expr
+          if expr: self.walkExpr(expr, armScope, ctx)
+        else:
+          self.walkStmts(arm.body ?? [], armScope, ctx)
+      return
+    if node.type == 'ReturnStmt':
+      if node.value: self.walkExpr(node.value, scope, ctx)
+      return
+    if node.type == 'ThrowStmt':
+      self.walkExpr(node.value, scope, ctx)
+      return
+    if node.type == 'TryCatchStmt':
+      val tryS = makeLintScope(scope, 'block')
+      self.walkStmts(node.tryBody, tryS, ctx)
+      if node.catchBody:
+        val catchS = makeLintScope(scope, 'block')
+        if node.catchParam:
+          val ce2 = catchS.define(node.catchParam, 'val', node.loc)
+          ce2.used = true
+        self.walkStmts(node.catchBody, catchS, ctx)
+      if node.finallyBody:
+        val finS = makeLintScope(scope, 'block')
+        self.walkStmts(node.finallyBody, finS, ctx)
+      return
+    if node.type == 'ImportDecl':
+      if node.defaultName:
+        val ie2 = scope.define(node.defaultName, 'val', node.loc)
+        ie2.used = true
+      if node.namespaceName:
+        val ne = scope.define(node.namespaceName, 'val', node.loc)
+        ne.used = true
+      for n in (node.names ?? []):
+        val nm = typeof n == 'string' ? n : n.alias
+        val ie3 = scope.define(nm, 'val', node.loc)
+        ie3.used = true
+      return
+    if node.type == 'ExportDecl':
+      var inner2 = node.decl
+      if node.isDefault: inner2 = { type: 'ExprStmt', expr: node.decl }
+      self.walkStmt(inner2, scope, ctx)
+      if node.decl and node.decl.name:
+        val ee = scope.lookup(node.decl.name)
+        if ee: ee.used = true; ee._exported = true
+      return
+    if node.type == 'ExprStmt':
+      self.walkExpr(node.expr, scope, ctx)
+
+  fn walkExpr(node, scope, ctx):
+    if not node: return
+    if node.type == 'Identifier':
+      scope.markUsed(node.name)
+      return
+    if node.type == 'AssignExpr':
+      self.walkExpr(node.target, scope, ctx)
+      self.walkExpr(node.value,  scope, ctx)
+      return
+    if node.type == 'UpdateExpr':
+      self.walkExpr(node.operand, scope, ctx)
+      return
+    if node.type == 'BinaryExpr' or node.type == 'PipeExpr':
+      self.walkExpr(node.left,  scope, ctx)
+      self.walkExpr(node.right, scope, ctx)
+      return
+    if node.type == 'UnaryExpr' or node.type == 'AwaitExpr' or node.type == 'TypeofExpr':
+      self.walkExpr(node.operand, scope, ctx)
+      return
+    if node.type == 'TernaryExpr':
+      self.walkExpr(node.cond,  scope, ctx)
+      self.walkExpr(node.then,  scope, ctx)
+      self.walkExpr(node.else_, scope, ctx)
+      return
+    if node.type == 'CallExpr' or node.type == 'OptCallExpr':
+      self.walkExpr(node.callee, scope, ctx)
+      for a in (node.args ?? []): self.walkExpr(a, scope, ctx)
+      return
+    if node.type == 'MemberExpr' or node.type == 'OptMemberExpr':
+      self.walkExpr(node.obj, scope, ctx)
+      return
+    if node.type == 'IndexExpr' or node.type == 'OptIndexExpr':
+      self.walkExpr(node.obj, scope, ctx)
+      self.walkExpr(node.idx, scope, ctx)
+      return
+    if node.type == 'NewExpr':
+      if node.callee: self.walkExpr(node.callee, scope, ctx)
+      for a in (node.args ?? []): self.walkExpr(a, scope, ctx)
+      return
+    if node.type == 'ArrayExpr':
+      for itm in (node.items ?? []): if itm: self.walkExpr(itm, scope, ctx)
+      return
+    if node.type == 'ObjectExpr':
+      for pair in (node.pairs ?? []): if pair.value: self.walkExpr(pair.value, scope, ctx)
+      return
+    if node.type == 'SpreadExpr':
+      self.walkExpr(node.expr, scope, ctx)
+      return
+    if node.type == 'LambdaExpr':
+      val lInner = makeLintScope(scope, 'fn')
+      for p in (node.params ?? []):
+        val pe = lInner.define(p.name, 'val', null)
+        pe.used = true
+      self.walkExpr(node.body, lInner, { ...ctx, inFn: true })
+      return
+    if node.type == 'FnDecl':
+      if node.name:
+        val fentry = scope.define(node.name, 'val', node.loc)
+        fentry.used = true
+      val fInner = makeLintScope(scope, 'fn')
+      for p in (node.params ?? []):
+        val pe2 = fInner.define(p.name, 'val', null)
+        pe2.used = true
+      if node.inline:
+        self.walkExpr(node.body, fInner, { ...ctx, inFn: true })
+      else:
+        self.walkStmts(node.body, fInner, { ...ctx, inFn: true })
+      return
+    if node.type == 'TemplateLit':
+      self.walkTemplateParts(node.parts ?? [], scope, ctx)
+      return
+    if (node.type == 'CastExpr' or node.type == 'AsConstExpr' or
+        node.type == 'SatisfiesExpr' or node.type == 'IsExpr' or node.type == 'NonNullExpr'):
+      self.walkExpr(node.expr, scope, ctx)
+      return
+    if node.type == 'RangeExpr':
+      self.walkExpr(node.start, scope, ctx)
+      self.walkExpr(node.end,   scope, ctx)
+
+  fn walkTemplateParts(parts, scope, ctx):
+    for p in parts:
+      if not p or p.type != 'expr': continue
+      try:
+        val tokens = lexerize(p.value).tokenize()
+        val expr   = makeParser(tokens).parseExpr()
+        self.walkExpr(expr, scope, ctx)
+      catch(err3):
+        val re = /\b([a-zA-Z_][a-zA-Z0-9_]*)\b/g
+        var m = re.exec(p.value)
+        while m:
+          scope.markUsed(m[1])
+          m = re.exec(p.value)
+
+// ── ShadowChecker ────────────────────────────────────────────
+export class ShadowChecker:
+  issues: any[]
+
+  fn check(ast):
+    self.issues = []
+    self.scWalkStmts(ast.body, makeLintScope(null, 'module'))
+    return self.issues
+
+  fn scWarn(name, inner, _outer):
+    self.issues.push(makeLintIssue('shadow-val', 'warn',
+      "'" + name + "' shadows an outer declaration",
+      "Rename one of the '" + name + "' variables to avoid confusion",
+      inner))
+
+  fn scDefine(scope, name, loc):
+    val outer = scope.lookupParent(name)
+    if outer and not isIgnoredName(name):
+      self.scWarn(name, loc, outer.loc)
+    scope.define(name, 'val', loc)
+
+  fn scWalkStmts(stmts, scope):
+    if not stmts: return
+    for node in stmts: self.scWalkStmt(node, scope)
+
+  fn scWalkStmt(node, scope):
+    if not node: return
+    if node.type == 'VarDecl':
+      if node.init: self.scWalkExpr(node.init, scope)
+      self.scDefine(scope, node.name, node.loc)
+      return
+    if node.type == 'DestructureDecl':
+      if node.init: self.scWalkExpr(node.init, scope)
+      if node.patternType == 'object':
+        for p in node.pattern: self.scDefine(scope, p.alias ?? p.name, node.loc)
+      else:
+        for p in node.pattern: if p: self.scDefine(scope, p.name, node.loc)
+      return
+    if node.type == 'FnDecl':
+      if node.name: self.scDefine(scope, node.name, node.loc)
+      val inner = makeLintScope(scope, 'fn')
+      for p in (node.params ?? []): self.scDefine(inner, p.name, node.loc)
+      if node.inline: self.scWalkExpr(node.body, inner)
+      else:           self.scWalkStmts(node.body, inner)
+      return
+    if node.type == 'ClassDecl':
+      self.scDefine(scope, node.name, node.loc)
+      val cls = makeLintScope(scope, 'class')
+      for m in (node.methods ?? []): self.scWalkStmt(m, cls)
+      return
+    if node.type == 'IfStmt':
+      self.scWalkExpr(node.cond, scope)
+      self.scWalkStmts(node.then, makeLintScope(scope, 'block'))
+      for ei in (node.elseifs ?? []):
+        self.scWalkExpr(ei.cond, scope)
+        self.scWalkStmts(ei.body, makeLintScope(scope, 'block'))
+      if node.else_: self.scWalkStmts(node.else_, makeLintScope(scope, 'block'))
+      return
+    if node.type == 'ForInStmt':
+      self.scWalkExpr(node.iter, scope)
+      val fs2 = makeLintScope(scope, 'block')
+      self.scDefine(fs2, node.var, node.loc)
+      self.scWalkStmts(node.body, fs2)
+      return
+    if node.type == 'WhileStmt':
+      self.scWalkExpr(node.cond, scope)
+      self.scWalkStmts(node.body, makeLintScope(scope, 'block'))
+      return
+    if node.type == 'DoWhileStmt':
+      self.scWalkStmts(node.body, makeLintScope(scope, 'block'))
+      self.scWalkExpr(node.cond, scope)
+      return
+    if node.type == 'MatchStmt':
+      self.scWalkExpr(node.subject, scope)
+      for arm in (node.arms ?? []):
+        val as2 = makeLintScope(scope, 'block')
+        if arm.pattern and arm.pattern.type == 'VariantPat':
+          for b in arm.pattern.bindings: self.scDefine(as2, b, node.loc)
+        if arm.guard: self.scWalkExpr(arm.guard, as2)
+        if arm.inline:
+          var scExpr = arm.body and arm.body[0] ? arm.body[0] : null
+          if arm.body and arm.body[0] and arm.body[0].expr: scExpr = arm.body[0].expr
+          if scExpr: self.scWalkExpr(scExpr, as2)
+        else:
+          self.scWalkStmts(arm.body ?? [], as2)
+      return
+    if node.type == 'ReturnStmt':
+      if node.value: self.scWalkExpr(node.value, scope)
+      return
+    if node.type == 'ThrowStmt':  self.scWalkExpr(node.value, scope); return
+    if node.type == 'ExprStmt':   self.scWalkExpr(node.expr,  scope); return
+    if node.type == 'TryCatchStmt':
+      self.scWalkStmts(node.tryBody, makeLintScope(scope, 'block'))
+      if node.catchBody:
+        val cs = makeLintScope(scope, 'block')
+        if node.catchParam: self.scDefine(cs, node.catchParam, node.loc)
+        self.scWalkStmts(node.catchBody, cs)
+      if node.finallyBody: self.scWalkStmts(node.finallyBody, makeLintScope(scope, 'block'))
+      return
+    if node.type == 'ImportDecl':
+      if node.defaultName:   self.scDefine(scope, node.defaultName,   node.loc)
+      if node.namespaceName: self.scDefine(scope, node.namespaceName, node.loc)
+      for n in (node.names ?? []):
+        self.scDefine(scope, typeof n == 'string' ? n : n.alias, node.loc)
+      return
+    if node.type == 'ExportDecl':
+      self.scWalkStmt(node.isDefault ? { type: 'ExprStmt', expr: node.decl } : node.decl, scope)
+
+  fn scWalkExpr(node, scope):
+    if not node: return
+    if node.type == 'LambdaExpr':
+      val inner = makeLintScope(scope, 'fn')
+      for p in (node.params ?? []): self.scDefine(inner, p.name, null)
+      self.scWalkExpr(node.body, inner)
+      return
+    if node.type == 'FnDecl':
+      val inner2 = makeLintScope(scope, 'fn')
+      for p in (node.params ?? []): self.scDefine(inner2, p.name, null)
+      if node.inline: self.scWalkExpr(node.body, inner2)
+      else:           self.scWalkStmts(node.body, inner2)
+      return
+    if node.type == 'BinaryExpr' or node.type == 'PipeExpr':
+      self.scWalkExpr(node.left, scope); self.scWalkExpr(node.right, scope); return
+    if (node.type == 'UnaryExpr' or node.type == 'AwaitExpr' or node.type == 'TypeofExpr' or
+        node.type == 'CastExpr'  or node.type == 'AsConstExpr' or node.type == 'SatisfiesExpr' or
+        node.type == 'IsExpr'    or node.type == 'NonNullExpr' or node.type == 'SpreadExpr'):
+      self.scWalkExpr(node.operand ?? node.expr, scope); return
+    if node.type == 'TernaryExpr':
+      self.scWalkExpr(node.cond,  scope)
+      self.scWalkExpr(node.then,  scope)
+      self.scWalkExpr(node.else_, scope); return
+    if node.type == 'CallExpr' or node.type == 'OptCallExpr':
+      self.scWalkExpr(node.callee, scope)
+      for a in (node.args ?? []): self.scWalkExpr(a, scope); return
+    if node.type == 'MemberExpr' or node.type == 'OptMemberExpr':
+      self.scWalkExpr(node.obj, scope); return
+    if node.type == 'IndexExpr' or node.type == 'OptIndexExpr':
+      self.scWalkExpr(node.obj, scope); self.scWalkExpr(node.idx, scope); return
+    if node.type == 'NewExpr':
+      if node.callee: self.scWalkExpr(node.callee, scope)
+      for a in (node.args ?? []): self.scWalkExpr(a, scope); return
+    if node.type == 'ArrayExpr':
+      for itm in (node.items ?? []): if itm: self.scWalkExpr(itm, scope); return
+    if node.type == 'ObjectExpr':
+      for pair in (node.pairs ?? []): if pair.value: self.scWalkExpr(pair.value, scope); return
+    if node.type == 'AssignExpr':
+      self.scWalkExpr(node.target, scope); self.scWalkExpr(node.value, scope); return
+    if node.type == 'UpdateExpr':
+      self.scWalkExpr(node.operand, scope); return
+    if node.type == 'RangeExpr':
+      self.scWalkExpr(node.start, scope); self.scWalkExpr(node.end, scope)
+
+export fn lint(ast):
+  val linter        = new Linter([])
+  val shadowChecker = new ShadowChecker([])
+  val unusedAndUnreachable = linter.lint(ast)
+  val shadows              = shadowChecker.check(ast)
+  val combined = [...unusedAndUnreachable, ...shadows]
+  combined.sort((a, b) -> (a.line ?? 0) - (b.line ?? 0))
+  return combined