@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/linthost/directives.go

@@ -34,8 +34,9 @@ const (
 
 // lintDirective is the parsed representation of one directive comment.
 type lintDirective struct {
-  kind  lintDirectiveKind
-  rules lintDirectiveRules
+  kind     lintDirectiveKind
+  rules    lintDirectiveRules
+  ruleList []string
 }
 
 // lintDirectiveRules holds the rule scope of a directive. When `all` is
@@ -55,13 +56,22 @@ type lintDirectiveEvent struct {
   on    bool
 }
 
+// lintDirectiveRecord preserves the per-directive rule list so the engine
+// can surface unknown rule names referenced by `// eslint-disable*` comments
+// (see `Engine.collectUnknownDirectiveRules`). The suppression path itself
+// only needs `rules`; this record exists purely for that diagnostic pass.
+type lintDirectiveRecord struct {
+  ruleList []string
+}
+
 // lintInlineDirectives accumulates the per-file directive information
 // extracted by parseLintInlineDirectives. `lines` maps a zero-based line
 // number to any disable-line / disable-next-line directives on that line.
 // `events` is the ordered list of range-style disable/enable transitions.
 type lintInlineDirectives struct {
-  lines  map[int][]lintDirectiveRules
-  events []lintDirectiveEvent
+  lines   map[int][]lintDirectiveRules
+  events  []lintDirectiveEvent
+  records []lintDirectiveRecord
 }
 
 // lintDisableState tracks the cumulative suppress/allow state as
@@ -75,11 +85,14 @@ type lintDisableState struct {
   enabledInAll map[string]struct{}
 }
 
-func filterInlineDisabledFindings(file *shimast.SourceFile, findings []*Finding) []*Finding {
+// filterInlineDisabledFindingsWithDirectives drops findings suppressed by
+// the directive set passed in. The caller is expected to have parsed
+// directives once via parseLintInlineDirectives and reuse them for any
+// other passes (e.g., Engine.collectUnknownDirectiveRules).
+func filterInlineDisabledFindingsWithDirectives(file *shimast.SourceFile, findings []*Finding, directives *lintInlineDirectives) []*Finding {
   if len(findings) == 0 || file == nil {
     return findings
   }
-  directives := parseLintInlineDirectives(file)
   if directives.empty() {
     return findings
   }
@@ -111,8 +124,19 @@ func parseLintInlineDirectives(file *shimast.SourceFile) *lintInlineDirectives {
   directives := &lintInlineDirectives{
     lines: make(map[int][]lintDirectiveRules),
   }
+  // Cheap byte-scan short-circuit: a file with no `-disable` or
+  // `-enable` substring cannot contain any recognized directive
+  // (`eslint-disable`, `lint-disable`, `eslint-enable`, `lint-enable`
+  // all match one of these). Running the full TypeScript scanner over
+  // every file just to find comments accounts for ~15 % of the lint
+  // engine's CPU on directive-free codebases; the substring check
+  // turns that into ~50 ns regardless of file size.
+  text := file.Text()
+  if !strings.Contains(text, "-disable") && !strings.Contains(text, "-enable") {
+    return directives
+  }
   scanner := shimscanner.NewScanner()
-  scanner.SetText(file.Text())
+  scanner.SetText(text)
   scanner.SetSkipTrivia(false)
 
   // templateBraceDepth tracks `{` nesting inside each open template
@@ -186,6 +210,9 @@ scan:
         on:    false,
       })
     }
+    directives.records = append(directives.records, lintDirectiveRecord{
+      ruleList: append([]string(nil), directive.ruleList...),
+    })
   }
   return directives
 }
@@ -193,7 +220,7 @@ scan:
 // empty reports whether no directives were found in the file, allowing the
 // caller to skip the filtering step entirely.
 func (d *lintInlineDirectives) empty() bool {
-  return d == nil || (len(d.lines) == 0 && len(d.events) == 0)
+  return d == nil || (len(d.lines) == 0 && len(d.events) == 0 && len(d.records) == 0)
 }
 
 // suppresses reports whether the directive set causes `finding` to be
@@ -259,8 +286,11 @@ func (s *lintDisableState) apply(event lintDirectiveEvent) {
 }
 
 // matches reports whether `rule` is currently suppressed given this state.
-// The name is normalized before lookup so that `@typescript-eslint/` prefixes
-// do not prevent a match.
+// The name is normalized before lookup so an optional `eslint/` prefix in
+// the directive does not prevent a match against the canonical rule id.
+// Legacy `@typescript-eslint/` / `react-hooks/` / `tsdoc/syntax` prefixes
+// are NOT normalized — they fall through to the unknown-rule path and
+// surface as `Engine.UnknownRules()` so users see the migration loudly.
 func (s lintDisableState) matches(rule string) bool {
   normalized := normalizeDirectiveRuleName(rule)
   if _, ok := s.rules[normalized]; ok {
@@ -336,9 +366,11 @@ func parseLintDirectiveLine(text string) (lintDirective, bool) {
       if !ok {
         continue
       }
+      parsed := parseDirectivePayload(payload)
       return lintDirective{
-        kind:  form.kind,
-        rules: parseDirectiveRules(payload),
+        kind:     form.kind,
+        rules:    parsed.rules,
+        ruleList: parsed.ruleList,
       }, true
     }
   }
@@ -363,10 +395,20 @@ func directivePayload(text, marker string) (string, bool) {
 // marker) into a lintDirectiveRules value. The `--` separator strips an
 // optional human-readable description. An empty rule list means "all rules".
 func parseDirectiveRules(payload string) lintDirectiveRules {
-  payload = stripDirectiveDescription(payload)
-  payload = strings.ReplaceAll(payload, ",", " ")
-  fields := strings.Fields(payload)
+  return parseDirectivePayload(payload).rules
+}
+
+type parsedDirectivePayload struct {
+  rules    lintDirectiveRules
+  ruleList []string
+}
+
+func parseDirectivePayload(payload string) parsedDirectivePayload {
+  ruleText := stripDirectiveDescription(payload)
+  ruleText = strings.ReplaceAll(ruleText, ",", " ")
+  fields := strings.Fields(ruleText)
   rules := make(map[string]struct{}, len(fields))
+  ruleList := make([]string, 0, len(fields))
   for _, field := range fields {
     if strings.HasPrefix(field, "--") {
       break
@@ -374,12 +416,16 @@ func parseDirectiveRules(payload string) lintDirectiveRules {
     name := normalizeDirectiveRuleName(field)
     if name != "" {
       rules[name] = struct{}{}
+      ruleList = append(ruleList, name)
     }
   }
   if len(rules) == 0 {
-    return lintDirectiveRules{all: true}
+    return parsedDirectivePayload{rules: lintDirectiveRules{all: true}}
+  }
+  return parsedDirectivePayload{
+    rules:    lintDirectiveRules{rules: rules},
+    ruleList: ruleList,
   }
-  return lintDirectiveRules{rules: rules}
 }
 
 // stripDirectiveDescription returns the portion of `payload` before the
@@ -398,15 +444,11 @@ func stripDirectiveDescription(payload string) string {
       return strings.TrimSpace(payload[:i])
     }
   }
-  return payload
+  return strings.TrimSpace(payload)
 }
 
-// normalizeDirectiveRuleName strips the common ESLint namespace prefixes so
-// both `@typescript-eslint/no-var` and `no-var` resolve to the same key.
+// normalizeDirectiveRuleName strips common ESLint namespace prefixes while
+// preserving the kebab/slash rule IDs diagnostics use.
 func normalizeDirectiveRuleName(name string) string {
-  name = strings.TrimSpace(name)
-  name = strings.TrimPrefix(name, "@typescript-eslint/")
-  name = strings.TrimPrefix(name, "typescript-eslint/")
-  name = strings.TrimPrefix(name, "eslint/")
-  return name
+  return normalizeBuiltinRuleName(name)
 }

package/linthost/dispatch.go

@@ -23,7 +23,8 @@ var Version = "dev"
 // caller should propagate to the OS (`os.Exit`) or the host (`Plugin.Run`).
 //
 // Recognized verbs: `version` / `-v` / `--version`, `check`, `fix`, `format`,
-// `build`, `transform`. Anything else is a usage error (exit code 2).
+// `build`, `transform`, and the `lsp-*` protocol commands consumed by
+// ttscserver. Anything else is a usage error (exit code 2).
 func Main(args []string) int {
   return run(args)
 }
@@ -33,7 +34,7 @@ func Main(args []string) int {
 // the same entry point the CLI uses.
 func run(args []string) int {
   if len(args) == 0 {
-    fmt.Fprintln(os.Stderr, "@ttsc/lint: command required (expected check|fix|format|build|transform|version)")
+    fmt.Fprintln(os.Stderr, "@ttsc/lint: command required (expected check|fix|format|build|transform|lsp-*|version)")
     return 2
   }
   switch args[0] {
@@ -41,7 +42,7 @@ func run(args []string) int {
     // Don't pay contributor-registration cost for the version banner.
     fmt.Fprintf(os.Stdout, "@ttsc/lint %s\n", Version)
     return 0
-  case "check", "fix", "format", "build", "transform":
+  case "check", "fix", "format", "build", "transform", "lsp-command-ids", "lsp-code-action-kinds", "lsp-diagnostics", "lsp-code-actions", "lsp-execute-command":
   default:
     fmt.Fprintf(os.Stderr, "@ttsc/lint: unknown command %q\n", args[0])
     return 2
@@ -60,6 +61,16 @@ func run(args []string) int {
     return RunBuild(args[1:])
   case "transform":
     return RunTransform(args[1:])
+  case "lsp-command-ids":
+    return RunLSPCommandIDs(args[1:])
+  case "lsp-code-action-kinds":
+    return RunLSPCodeActionKinds(args[1:])
+  case "lsp-diagnostics":
+    return RunLSPDiagnostics(args[1:])
+  case "lsp-code-actions":
+    return RunLSPCodeActions(args[1:])
+  case "lsp-execute-command":
+    return RunLSPExecuteCommand(args[1:])
   }
   return 2
 }

package/linthost/engine.go

@@ -246,13 +246,22 @@ func AllRuleNames() []string {
 
 // Engine binds a rule configuration to a Program and walks the AST once
 // per source file, dispatching each visited node to its interested rules.
+//
+// `rules` is a fixed-size slice indexed by `shimast.Kind` value rather
+// than a map. `KindCount` (~350) is small and bounded, and the slice
+// removes a per-node map hash from the hot path — a `walk(node)` over a
+// 50k-node file performs 50k dispatch lookups. The conversion is
+// equivalent in semantics; entries for unused kinds are nil and the
+// per-rule slice still grows by append.
 type Engine struct {
-  config           RuleResolver
-  rules            map[shimast.Kind][]Rule
-  enabled          map[string]Severity
-  unknown          []string
-  needsTypeChecker bool
-  serial           bool
+  config             RuleResolver
+  rules              [][]Rule
+  enabled            map[string]Severity
+  unknown            []string
+  unknownDirectives  map[string]struct{}
+  unknownDirectiveMu sync.Mutex
+  needsTypeChecker   bool
+  serial             bool
 }
 
 // SetSerial forces Engine.Run to walk files one at a time. The host calls
@@ -290,9 +299,10 @@ func NewEngineWithResolver(config RuleResolver) *Engine {
     config = RuleConfig{}
   }
   eng := &Engine{
-    config:  config,
-    rules:   make(map[shimast.Kind][]Rule),
-    enabled: make(map[string]Severity),
+    config:            config,
+    rules:             make([][]Rule, int(shimast.KindCount)),
+    enabled:           make(map[string]Severity),
+    unknownDirectives: make(map[string]struct{}),
   }
   displaySeverities := config.EnabledRuleConfig()
   for _, name := range config.ActiveRuleNames() {
@@ -313,16 +323,91 @@ func NewEngineWithResolver(config RuleResolver) *Engine {
         continue
       }
       seen[kind] = struct{}{}
-      eng.rules[kind] = append(eng.rules[kind], rule)
+      idx := int(kind)
+      if idx < 0 || idx >= len(eng.rules) {
+        // Defensive: a contributor returning a Kind beyond the
+        // shim's KindCount would otherwise panic on dispatch.
+        continue
+      }
+      eng.rules[idx] = append(eng.rules[idx], rule)
     }
   }
   sort.Strings(eng.unknown)
   return eng
 }
 
-// UnknownRules returns the names of rules that appeared in the config but
-// have no registered implementation.
-func (e *Engine) UnknownRules() []string { return e.unknown }
+// UnknownRules returns the names of rules that appeared either in the
+// config or in an inline `eslint-disable*` directive but have no
+// registered implementation. Directive-side unknowns are deduped so the
+// same misspelling on every page doesn't flood the warning channel.
+func (e *Engine) UnknownRules() []string {
+  if e == nil {
+    return nil
+  }
+  e.unknownDirectiveMu.Lock()
+  extras := make([]string, 0, len(e.unknownDirectives))
+  for name := range e.unknownDirectives {
+    extras = append(extras, name)
+  }
+  e.unknownDirectiveMu.Unlock()
+  if len(extras) == 0 {
+    return e.unknown
+  }
+  seen := make(map[string]struct{}, len(e.unknown)+len(extras))
+  out := make([]string, 0, len(e.unknown)+len(extras))
+  for _, name := range e.unknown {
+    if _, dup := seen[name]; dup {
+      continue
+    }
+    seen[name] = struct{}{}
+    out = append(out, name)
+  }
+  for _, name := range extras {
+    if _, dup := seen[name]; dup {
+      continue
+    }
+    seen[name] = struct{}{}
+    out = append(out, name)
+  }
+  sort.Strings(out)
+  return out
+}
+
+// collectUnknownDirectiveRules walks every directive's rule list and
+// records names that don't resolve to a registered rule. Called once
+// per file after `parseLintInlineDirectives`.
+func (e *Engine) collectUnknownDirectiveRules(directives *lintInlineDirectives) {
+  if e == nil || directives == nil {
+    return
+  }
+  for _, rec := range directives.records {
+    for _, raw := range rec.ruleList {
+      name := normalizeDirectiveRuleName(raw)
+      if name == "" {
+        continue
+      }
+      if _, ok := registered.rules[name]; ok {
+        continue
+      }
+      e.recordUnknownDirectiveRule(name)
+    }
+  }
+}
+
+// recordUnknownDirectiveRule remembers a rule name referenced by an
+// `// eslint-disable*` directive that does not resolve to a registered
+// rule. Each unique name is recorded once across the engine run.
+func (e *Engine) recordUnknownDirectiveRule(name string) {
+  if e == nil || name == "" {
+    return
+  }
+  e.unknownDirectiveMu.Lock()
+  defer e.unknownDirectiveMu.Unlock()
+  if e.unknownDirectives == nil {
+    e.unknownDirectives = make(map[string]struct{})
+  }
+  e.unknownDirectives[name] = struct{}{}
+}
 
 // NeedsTypeChecker reports whether any active rule requires Context.Checker.
 func (e *Engine) NeedsTypeChecker() bool {
@@ -393,6 +478,40 @@ type boundRule struct {
   ctx  *Context
 }
 
+// lintFileWalker drives the per-file AST traversal. The struct exists so
+// the `ForEachChild` callback can be a method value cached in
+// `childCB`. A naive nested-closure walker re-allocates one callback
+// per recursive call (it captures the walking function variable),
+// which on a 50 k-node file is 50 k throwaway closure allocations.
+// Caching the method value reduces that to one allocation per file.
+type lintFileWalker struct {
+  byKind  [][]boundRule
+  collect func(*Finding)
+  childCB func(*shimast.Node) bool
+}
+
+// walk dispatches a single node to every rule that registered for the
+// node's Kind, then recurses into children via the cached childCB.
+func (w *lintFileWalker) walk(node *shimast.Node) {
+  if node == nil {
+    return
+  }
+  if k := int(node.Kind); k >= 0 && k < len(w.byKind) {
+    for _, bound := range w.byKind[k] {
+      runRuleCheck(bound.rule, bound.ctx, node, w.collect)
+    }
+  }
+  node.ForEachChild(w.childCB)
+}
+
+// visitChild is the cached ForEachChild callback. It is the method
+// value stored in `childCB` so per-recursion closure allocation is
+// avoided.
+func (w *lintFileWalker) visitChild(child *shimast.Node) bool {
+  w.walk(child)
+  return false
+}
+
 // runFile is the per-file driver. The visitor is allocated once per file
 // to keep the per-node hot path branch-free; it visits children
 // post-order so parents see their already-checked subtrees.
@@ -415,9 +534,12 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
   // Context for every (node, rule) pair, which on a large program meant
   // millions of short-lived heap allocations and the GC pressure they
   // carry. Rules never mutate their Context, so reuse is safe.
-  byKind := make(map[shimast.Kind][]boundRule, len(e.rules))
+  byKind := make([][]boundRule, len(e.rules))
   ctxByRule := make(map[string]*Context, len(e.enabled))
   for kind, rules := range e.rules {
+    if len(rules) == 0 {
+      continue
+    }
     for _, rule := range rules {
       name := rule.Name()
       ctx, built := ctxByRule[name]
@@ -444,40 +566,39 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
     }
   }
 
-  var walk func(node *shimast.Node)
-  walk = func(node *shimast.Node) {
-    if node == nil {
-      return
-    }
-    for _, bound := range byKind[node.Kind] {
-      runRuleCheck(bound.rule, bound.ctx, node, collect)
-    }
-    node.ForEachChild(func(child *shimast.Node) bool {
-      walk(child)
-      return false // visit every child
-    })
-  }
+  // Use a struct-based walker so the per-node ForEachChild callback is
+  // allocated once (stored as `w.childCB`) instead of once per Walk
+  // call. Closures that capture a recursive local function escape to
+  // the heap on every invocation; converting to a method value with a
+  // cached function field removes that allocation from the hot path —
+  // ~38 % of pre-Opt-4 CPU was in the inner ForEachChild closure.
+  w := &lintFileWalker{byKind: byKind, collect: collect}
+  w.childCB = w.visitChild
 
   // SourceFile dispatches into its statement list directly; we walk
   // statements explicitly so the file node itself can be inspected by
   // rules (e.g., `ban-ts-comment` reads CommentDirectives off the
   // SourceFile).
-  for _, bound := range byKind[shimast.KindSourceFile] {
-    runRuleCheck(bound.rule, bound.ctx, file.AsNode(), collect)
+  if k := int(shimast.KindSourceFile); k >= 0 && k < len(byKind) {
+    for _, bound := range byKind[k] {
+      runRuleCheck(bound.rule, bound.ctx, file.AsNode(), collect)
+    }
   }
 
   statements := file.Statements
   if statements != nil {
     for _, stmt := range statements.Nodes {
-      walk(stmt)
+      w.walk(stmt)
     }
   }
+  directives := parseLintInlineDirectives(file)
+  e.collectUnknownDirectiveRules(directives)
   // Apply inline-disable filtering even for files with no statement
   // list. A SourceFile-level rule that fires on a `// ttsc-lint-disable`
   // comment must still honor the directive; early-returning before
   // the filter would silently leak those findings into the diagnostic
   // stream.
-  return filterInlineDisabledFindings(file, collected)
+  return filterInlineDisabledFindingsWithDirectives(file, collected, directives)
 }
 
 func hasEnabledFileRules(rules RuleConfig) bool {

package/linthost/fix.go

@@ -16,8 +16,8 @@ import (
   shimdw "github.com/microsoft/typescript-go/shim/diagnosticwriter"
 )
 
-// maxFixPasses bounds the native fix cascade. Real-world cascades (no-var →
-// prefer-const → eqeqeq …) settle in a handful of passes; the cap exists so
+// maxFixPasses bounds the native fix cascade. Real-world cascades (noVar →
+// preferConst → eqeqeq …) settle in a handful of passes; the cap exists so
 // a buggy rule that re-reports its own edit cannot loop forever.
 const maxFixPasses = 10