@ttsc/lint 0.13.0 → 0.14.0-dev.20260528

package/linthost/rules_no_mixed_operators.go

@@ -0,0 +1,80 @@
+// noMixedOperators flags expressions that mix operators from different
+// precedence families without explicit parentheses around the inner
+// expression. The classic gotcha is `a && b || c` — readers expect
+// left-to-right grouping, but `&&` binds tighter than `||`, so the
+// parse tree is actually `(a && b) || c`. Wrapping the inner
+// sub-expression in parens removes the ambiguity for both the parser
+// and the reader.
+//
+// The conservative baseline fires only on the highest-confusion mixes:
+// logical mixed with a different logical, logical mixed with bitwise,
+// and bitwise mixed with comparison. Same-operator chains (`a && b &&
+// c`) and parenthesized inner children (`(a && b) || c`) never fire.
+// https://eslint.org/docs/latest/rules/no-mixed-operators
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type noMixedOperators struct{}
+
+const (
+	mixedGroupLogical    = 1
+	mixedGroupBitwise    = 2
+	mixedGroupComparison = 3
+)
+
+func (noMixedOperators) Name() string         { return "no-mixed-operators" }
+func (noMixedOperators) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
+func (noMixedOperators) Check(ctx *Context, node *shimast.Node) {
+	expr := node.AsBinaryExpression()
+	if expr == nil || expr.OperatorToken == nil {
+		return
+	}
+	parent := noMixedOperatorsGroup(expr.OperatorToken.Kind)
+	if parent == 0 {
+		return
+	}
+	op := expr.OperatorToken.Kind
+	if noMixedOperatorsConflicts(parent, op, expr.Left) ||
+		noMixedOperatorsConflicts(parent, op, expr.Right) {
+		ctx.Report(node, "Unexpected mix of different operators. Wrap the inner expression in parentheses to make the grouping explicit.")
+	}
+}
+
+// noMixedOperatorsConflicts returns true when `child` is an
+// unparenthesized BinaryExpression whose operator group is confusing
+// next to the parent group. Same operator never conflicts.
+func noMixedOperatorsConflicts(parent int, parentOp shimast.Kind, child *shimast.Node) bool {
+	if child == nil || child.Kind != shimast.KindBinaryExpression {
+		return false
+	}
+	inner := child.AsBinaryExpression()
+	if inner == nil || inner.OperatorToken == nil || inner.OperatorToken.Kind == parentOp {
+		return false
+	}
+	g := noMixedOperatorsGroup(inner.OperatorToken.Kind)
+	if g == 0 {
+		return false
+	}
+	if parent == mixedGroupLogical {
+		return g == mixedGroupLogical || g == mixedGroupBitwise
+	}
+	return parent == mixedGroupBitwise && (g == mixedGroupLogical || g == mixedGroupComparison)
+}
+
+func noMixedOperatorsGroup(op shimast.Kind) int {
+	switch op {
+	case shimast.KindAmpersandAmpersandToken, shimast.KindBarBarToken, shimast.KindQuestionQuestionToken:
+		return mixedGroupLogical
+	case shimast.KindAmpersandToken, shimast.KindBarToken, shimast.KindCaretToken:
+		return mixedGroupBitwise
+	case shimast.KindEqualsEqualsToken, shimast.KindEqualsEqualsEqualsToken,
+		shimast.KindExclamationEqualsToken, shimast.KindExclamationEqualsEqualsToken,
+		shimast.KindLessThanToken, shimast.KindLessThanEqualsToken,
+		shimast.KindGreaterThanToken, shimast.KindGreaterThanEqualsToken:
+		return mixedGroupComparison
+	}
+	return 0
+}
+
+func init() { Register(noMixedOperators{}) }

package/linthost/rules_no_param_reassign.go

@@ -0,0 +1,98 @@
+// noParamReassign: reassigning a function parameter inside the body of
+// the function it belongs to. Mutating the binding makes the declared
+// name stop pointing at the caller's argument and is the usual ESLint
+// baseline of `no-param-reassign` — without the `props: true` extension
+// that would also flag `param.foo = …`.
+//
+// Conservative scope tracking: collect simple-identifier parameter
+// names, walk the body until a nested function-like introduces a fresh
+// scope, and flag `name = …` / `name op= …` / `++name` / `name--` at
+// any depth in between. A local `const name = 1` that shadows a
+// parameter name will produce a false positive in v1 — proper scope
+// tracking needs the resolver, which the AST-only baseline avoids.
+// Destructured parameter bindings are skipped for the same reason.
+// https://eslint.org/docs/latest/rules/no-param-reassign
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type noParamReassign struct{}
+
+func (noParamReassign) Name() string { return "no-param-reassign" }
+func (noParamReassign) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindFunctionDeclaration,
+		shimast.KindFunctionExpression,
+		shimast.KindArrowFunction,
+		shimast.KindMethodDeclaration,
+		shimast.KindConstructor,
+		shimast.KindGetAccessor,
+		shimast.KindSetAccessor,
+	}
+}
+func (noParamReassign) Check(ctx *Context, node *shimast.Node) {
+	body := node.Body()
+	if body == nil {
+		return
+	}
+	names := map[string]bool{}
+	for _, p := range node.Parameters() {
+		if decl := p.AsParameterDeclaration(); decl != nil {
+			if name := identifierText(decl.Name()); name != "" {
+				names[name] = true
+			}
+		}
+	}
+	if len(names) == 0 {
+		return
+	}
+	walkParamReassignBody(body, names, func(target *shimast.Node) {
+		ctx.Report(target, "Assignment to function parameter.")
+	})
+}
+
+// walkParamReassignBody visits every assignment-like write in `root`
+// without crossing nested function-like scopes. The target identifier
+// must be a bare name in `names` for `report` to fire.
+func walkParamReassignBody(root *shimast.Node, names map[string]bool, report func(*shimast.Node)) {
+	if root == nil {
+		return
+	}
+	var walk func(*shimast.Node)
+	hits := func(operand *shimast.Node) bool {
+		name := identifierText(stripParens(operand))
+		return name != "" && names[name]
+	}
+	walk = func(node *shimast.Node) {
+		if node == nil || (node != root && isFunctionLikeKind(node)) {
+			return
+		}
+		switch node.Kind {
+		case shimast.KindBinaryExpression:
+			expr := node.AsBinaryExpression()
+			if expr != nil && expr.OperatorToken != nil &&
+				isAssignmentOperator(expr.OperatorToken.Kind) && hits(expr.Left) {
+				report(node)
+			}
+		case shimast.KindPrefixUnaryExpression:
+			pre := node.AsPrefixUnaryExpression()
+			if pre != nil && (pre.Operator == shimast.KindPlusPlusToken || pre.Operator == shimast.KindMinusMinusToken) && hits(pre.Operand) {
+				report(node)
+			}
+		case shimast.KindPostfixUnaryExpression:
+			post := node.AsPostfixUnaryExpression()
+			if post != nil && (post.Operator == shimast.KindPlusPlusToken || post.Operator == shimast.KindMinusMinusToken) && hits(post.Operand) {
+				report(node)
+			}
+		}
+		node.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return false
+		})
+	}
+	walk(root)
+}
+
+func init() {
+	Register(noParamReassign{})
+}

package/linthost/rules_no_redeclare.go

@@ -0,0 +1,270 @@
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// noRedeclare: reject declaring the same binding more than once in the
+// same scope. The second declaration silently overwrites the first;
+// shadowing the binding in a nested scope is left alone because the
+// inner declaration introduces a fresh binding.
+// https://eslint.org/docs/latest/rules/no-redeclare
+//
+// Each visited scope (source file, module block, or block) builds a
+// `name -> first node` map by walking only the immediate statement
+// list — nested blocks introduce their own scopes and are processed by
+// a separate visit. The exception is `var`: it hoists to the nearest
+// function-like container, so a function-scope visit also descends
+// past inner blocks to pull every nested `var` into the function
+// scope. Function overload signatures share the implementation's name
+// by design and are skipped, mirroring ESLint's behavior.
+type noRedeclare struct{}
+
+func (noRedeclare) Name() string { return "no-redeclare" }
+func (noRedeclare) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile, shimast.KindModuleBlock, shimast.KindBlock}
+}
+func (noRedeclare) Check(ctx *Context, node *shimast.Node) {
+  statements := scopeStatements(node)
+  if statements == nil {
+    return
+  }
+  isFunctionScope := isFunctionScopeContainer(node)
+  seen := map[string]*shimast.Node{}
+
+  report := func(name string, declNode *shimast.Node) {
+    if prior, exists := seen[name]; exists {
+      _ = prior
+      ctx.Report(declNode, "'"+name+"' is already defined.")
+      return
+    }
+    seen[name] = declNode
+  }
+
+  // A function-body block inherits its parameters as the outermost
+  // bindings of the function scope. Pre-seed the seen map so a later
+  // `var` or function declaration with the same name reports.
+  if isFunctionScope && node.Kind == shimast.KindBlock && node.Parent != nil && isFunctionLikeKind(node.Parent) {
+    for _, name := range parameterBindingNames(node.Parent) {
+      if name != "" {
+        seen[name] = node.Parent
+      }
+    }
+  }
+
+  // Pass 1: block-scoped declarations from the immediate statement
+  // list. `var` statements only contribute here in function-scope
+  // containers — inside a plain block they belong to the enclosing
+  // function scope and are reported there instead.
+  for _, stmt := range statements {
+    if stmt == nil {
+      continue
+    }
+    if stmt.Kind == shimast.KindVariableStatement && !isFunctionScope {
+      vs := stmt.AsVariableStatement()
+      if vs != nil && vs.DeclarationList != nil && shimast.IsVar(vs.DeclarationList) {
+        continue
+      }
+    }
+    for _, name := range immediateDeclarationNames(stmt) {
+      if name != "" {
+        report(name, stmt)
+      }
+    }
+  }
+
+  // Pass 2: var hoisting. Function scopes (source file, module block,
+  // function body) also collect every `var` declared in nested blocks
+  // up to the next function-like boundary. Top-level `var` statements
+  // are already reported in Pass 1, so this pass descends into each
+  // statement's children rather than visiting the statement itself.
+  if isFunctionScope {
+    for _, stmt := range statements {
+      if stmt == nil || stmt.Kind == shimast.KindVariableStatement {
+        continue
+      }
+      collectHoistedVarsInto(stmt, func(name string, declNode *shimast.Node) {
+        if name != "" {
+          report(name, declNode)
+        }
+      })
+    }
+  }
+}
+
+// scopeStatements returns the direct statement list of a scope-defining
+// container (source file, module block, or block). Returns nil for any
+// other node kind so the caller can bail without further checks.
+func scopeStatements(node *shimast.Node) []*shimast.Node {
+  switch node.Kind {
+  case shimast.KindSourceFile:
+    file := node.AsSourceFile()
+    if file != nil && file.Statements != nil {
+      return file.Statements.Nodes
+    }
+  case shimast.KindModuleBlock:
+    mb := node.AsModuleBlock()
+    if mb != nil && mb.Statements != nil {
+      return mb.Statements.Nodes
+    }
+  case shimast.KindBlock:
+    block := node.AsBlock()
+    if block != nil && block.Statements != nil {
+      return block.Statements.Nodes
+    }
+  }
+  return nil
+}
+
+// isFunctionScopeContainer reports whether node is a scope into which
+// `var` declarations hoist: the source file, a module block, or a
+// block that forms the body of a function-like declaration.
+func isFunctionScopeContainer(node *shimast.Node) bool {
+  switch node.Kind {
+  case shimast.KindSourceFile, shimast.KindModuleBlock:
+    return true
+  case shimast.KindBlock:
+    return node.Parent != nil && isFunctionLikeKind(node.Parent)
+  }
+  return false
+}
+
+// immediateDeclarationNames returns every binding name introduced by a
+// single top-level statement of a scope. Variable statements contribute
+// their identifier names regardless of `var`/`let`/`const` keyword;
+// function and class declarations contribute their own name. Overload
+// signatures (`function f(): void;` with no body) are skipped because
+// they intentionally repeat the implementation's name. Ambient
+// declarations (`declare var x: …`, `declare function f(): …`) are
+// also skipped — TypeScript merges them with concrete declarations of
+// the same name by design.
+func immediateDeclarationNames(stmt *shimast.Node) []string {
+  if stmt == nil {
+    return nil
+  }
+  if stmt.ModifierFlags()&shimast.ModifierFlagsAmbient != 0 {
+    return nil
+  }
+  switch stmt.Kind {
+  case shimast.KindVariableStatement:
+    return variableStatementBindingNames(stmt)
+  case shimast.KindFunctionDeclaration:
+    decl := stmt.AsFunctionDeclaration()
+    if decl == nil || decl.Body == nil {
+      return nil
+    }
+    if name := identifierText(decl.Name()); name != "" {
+      return []string{name}
+    }
+  case shimast.KindClassDeclaration:
+    decl := stmt.AsClassDeclaration()
+    if decl == nil {
+      return nil
+    }
+    if name := identifierText(decl.Name()); name != "" {
+      return []string{name}
+    }
+  }
+  return nil
+}
+
+// variableStatementBindingNames returns the identifier name of every
+// declaration in a `var`/`let`/`const` statement. Destructuring
+// patterns (`const { a } = obj`) are skipped — the rule cannot reason
+// about pattern equality without scope resolution, so the conservative
+// baseline only handles plain identifier bindings.
+func variableStatementBindingNames(stmt *shimast.Node) []string {
+  vs := stmt.AsVariableStatement()
+  if vs == nil || vs.DeclarationList == nil {
+    return nil
+  }
+  list := vs.DeclarationList.AsVariableDeclarationList()
+  if list == nil || list.Declarations == nil {
+    return nil
+  }
+  var names []string
+  for _, decl := range list.Declarations.Nodes {
+    if decl == nil {
+      continue
+    }
+    v := decl.AsVariableDeclaration()
+    if v == nil {
+      continue
+    }
+    if name := identifierText(v.Name()); name != "" {
+      names = append(names, name)
+    }
+  }
+  return names
+}
+
+// parameterBindingNames returns the identifier name of every plain
+// parameter on a function-like node. Destructured parameters are
+// skipped for the same reason as variableStatementBindingNames.
+func parameterBindingNames(fn *shimast.Node) []string {
+  params := fn.Parameters()
+  if len(params) == 0 {
+    return nil
+  }
+  var names []string
+  for _, param := range params {
+    if param == nil {
+      continue
+    }
+    decl := param.AsParameterDeclaration()
+    if decl == nil {
+      continue
+    }
+    if name := identifierText(decl.Name()); name != "" {
+      names = append(names, name)
+    }
+  }
+  return names
+}
+
+// collectHoistedVarsInto walks every descendant of node up to (but
+// not into) a nested function-like boundary, invoking yield for each
+// `var` binding it discovers. Both `var` statements and `for (var i …)`
+// declaration lists contribute; the former carries a VariableStatement
+// kind so the surrounding statement reports, the latter carries a bare
+// VariableDeclarationList so each individual VariableDeclaration node
+// reports. Plain identifier bindings only — destructuring patterns are
+// skipped to keep the rule reliable.
+func collectHoistedVarsInto(node *shimast.Node, yield func(string, *shimast.Node)) {
+  if node == nil || isFunctionLikeKind(node) {
+    return
+  }
+  if node.Kind == shimast.KindVariableStatement {
+    vs := node.AsVariableStatement()
+    if vs != nil && vs.DeclarationList != nil && shimast.IsVar(vs.DeclarationList) {
+      for _, name := range variableStatementBindingNames(node) {
+        yield(name, node)
+      }
+    }
+    return
+  }
+  if node.Kind == shimast.KindVariableDeclarationList {
+    list := node.AsVariableDeclarationList()
+    if list != nil && shimast.IsVar(node) && list.Declarations != nil {
+      for _, decl := range list.Declarations.Nodes {
+        if decl == nil {
+          continue
+        }
+        v := decl.AsVariableDeclaration()
+        if v == nil {
+          continue
+        }
+        if name := identifierText(v.Name()); name != "" {
+          yield(name, decl)
+        }
+      }
+    }
+    return
+  }
+  node.ForEachChild(func(child *shimast.Node) bool {
+    collectHoistedVarsInto(child, yield)
+    return false
+  })
+}
+
+func init() {
+  Register(noRedeclare{})
+}

package/linthost/rules_no_restricted_imports.go

@@ -0,0 +1,105 @@
+// noRestrictedImports reports an `import` (or `export … from`) whose
+// module specifier matches a project-configured deny list. The rule is
+// the policy hammer for forcing a module boundary: a package that has
+// been renamed, a workspace internal that should not leak, or a heavy
+// dependency that the project wants to discourage all share the same
+// shape — flag the import at its source so the offending line is the
+// one the developer fixes.
+//
+// Configuration shape: a `paths` array of bare module specifiers to
+// flag, exact-match only. An empty (or missing) list is a no-op — the
+// rule contributes no findings until the project lists something to
+// restrict. The native engine's RuleConfig path does not carry options
+// to the rule, so the Go unit test exercises the rule via a hard-coded
+// default deny list (`lodash`, `underscore`) that fires whenever the
+// rule is enabled with no options blob.
+// https://eslint.org/docs/latest/rules/no-restricted-imports
+package linthost
+
+import (
+	"encoding/json"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type noRestrictedImports struct{}
+
+// noRestrictedImportsOptions decodes the `paths` array from a user
+// `[severity, options]` tuple. Anything else on the blob is ignored so
+// future ESLint-compatible keys (e.g. `patterns`) can be layered in
+// without changing existing configs.
+type noRestrictedImportsOptions struct {
+	Paths []string `json:"paths"`
+}
+
+// hardCodedRestrictedImports is the default deny list used when the
+// rule is enabled without an options blob. The Go-side test harness
+// exercises the rule through `RuleConfig` (severity-only, no options),
+// so the rule needs a deterministic non-empty default to be testable
+// at the AST layer at all. The choice mirrors a common "don't lean on
+// utility-belt libraries" lint setup in real projects.
+var hardCodedRestrictedImports = []string{"lodash", "underscore"}
+
+func (noRestrictedImports) Name() string { return "no-restricted-imports" }
+func (noRestrictedImports) Visits() []shimast.Kind {
+	return []shimast.Kind{
+		shimast.KindImportDeclaration,
+		shimast.KindExportDeclaration,
+	}
+}
+func (noRestrictedImports) Check(ctx *Context, node *shimast.Node) {
+	specifierNode := moduleSpecifierOf(node)
+	if specifierNode == nil {
+		return
+	}
+	specifier := stringLiteralText(specifierNode)
+	if specifier == "" {
+		return
+	}
+	denied := resolveNoRestrictedImportsPaths(ctx)
+	for _, target := range denied {
+		if specifier == target {
+			ctx.Report(specifierNode, "'"+specifier+"' import is restricted from being used.")
+			return
+		}
+	}
+}
+
+// moduleSpecifierOf returns the `from "…"` string-literal node of the
+// import / re-export declaration. `export { x }` (no `from`) and
+// every other shape returns nil so the caller short-circuits.
+func moduleSpecifierOf(node *shimast.Node) *shimast.Node {
+	if node == nil {
+		return nil
+	}
+	switch node.Kind {
+	case shimast.KindImportDeclaration:
+		if imp := node.AsImportDeclaration(); imp != nil {
+			return imp.ModuleSpecifier
+		}
+	case shimast.KindExportDeclaration:
+		if exp := node.AsExportDeclaration(); exp != nil {
+			return exp.ModuleSpecifier
+		}
+	}
+	return nil
+}
+
+// resolveNoRestrictedImportsPaths returns the active deny list for the
+// firing context. A `paths` array on the user's options blob wins; an
+// empty / missing blob falls back to `hardCodedRestrictedImports` so
+// the AST-layer test fires deterministically.
+func resolveNoRestrictedImportsPaths(ctx *Context) []string {
+	if ctx == nil || len(ctx.Options) == 0 {
+		return hardCodedRestrictedImports
+	}
+	var opts noRestrictedImportsOptions
+	if err := json.Unmarshal(ctx.Options, &opts); err != nil || len(opts.Paths) == 0 {
+		return hardCodedRestrictedImports
+	}
+	return opts.Paths
+}
+
+func init() {
+	Register(noRestrictedImports{})
+}

package/linthost/rules_no_restricted_syntax.go

@@ -0,0 +1,49 @@
+// noRestrictedSyntax: a project-level escape hatch that lets a team
+// ban specific AST node kinds outright. Upstream ESLint accepts an
+// arbitrary selector list and a per-entry message; without the
+// rule-options plumbing, this baseline ships a fixed default set that
+// covers the two syntactic constructs almost every modern TypeScript
+// project forbids: `with` (replaced by destructuring / explicit access
+// long ago) and labeled statements (used only to bridge complex
+// nested loops, which are themselves better refactored). The full
+// configurable surface is deferred — projects that need a custom
+// denylist can stack additional rules until option decoding lands.
+// https://eslint.org/docs/latest/rules/no-restricted-syntax
+package linthost
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// noRestrictedSyntaxDefault is the built-in denylist surfaced when no
+// config is supplied. Each entry pairs a banned node kind with the
+// short, actionable message reported at the offending node.
+var noRestrictedSyntaxDefault = map[shimast.Kind]string{
+	shimast.KindWithStatement:    "`with` statements are restricted — use explicit property access instead.",
+	shimast.KindLabeledStatement: "Labeled statements are restricted — refactor the surrounding control flow instead.",
+}
+
+type noRestrictedSyntax struct{}
+
+func (noRestrictedSyntax) Name() string { return "no-restricted-syntax" }
+func (noRestrictedSyntax) Visits() []shimast.Kind {
+	kinds := make([]shimast.Kind, 0, len(noRestrictedSyntaxDefault))
+	for kind := range noRestrictedSyntaxDefault {
+		kinds = append(kinds, kind)
+	}
+	return kinds
+}
+func (noRestrictedSyntax) Check(ctx *Context, node *shimast.Node) {
+	if node == nil {
+		return
+	}
+	message, banned := noRestrictedSyntaxDefault[node.Kind]
+	if !banned {
+		return
+	}
+	ctx.Report(node, message)
+}
+
+func init() {
+	Register(noRestrictedSyntax{})
+}