@ttsc/lint 0.10.2 → 0.11.0-dev.20260517

package/{plugin → linthost}/engine.go

@@ -15,9 +15,12 @@
 // and may not retain references to the previous file. This keeps the
 // engine concurrent-friendly even though the v0 implementation runs
 // serially.
-package main
+package linthost
 
 import (
+  "encoding/json"
+  "fmt"
+  "os"
   "sort"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -43,18 +46,66 @@ type Rule interface {
   Check(ctx *Context, node *shimast.Node)
 }
 
+// FormatRule is an optional marker interface that tags a Rule as a
+// formatter. `ttsc fix` is the run-everything entry point — it applies
+// edits from BOTH lint-class rules and FormatRule rules. `ttsc format`
+// is the format-only convenience: it filters to FormatRule findings so
+// lint-class rewrites are skipped. The marker exists so the format
+// filter can pick the right half; fix needs no filter.
+//
+// FormatRule.IsFormat must return true unconditionally — the method
+// exists as a structural marker, not a runtime toggle. Returning false
+// is treated by the engine as "not a format rule" and is equivalent to
+// not implementing the interface at all.
+type FormatRule interface {
+  Rule
+  IsFormat() bool
+}
+
+// isFormatRule reports whether `r` opts into the format category.
+func isFormatRule(r Rule) bool {
+  fr, ok := r.(FormatRule)
+  return ok && fr.IsFormat()
+}
+
 // Context is the per-(file, rule) handle the engine passes to `Check`.
+//
+// `Options` is the raw JSON blob the user wrote in their rule
+// configuration's second tuple slot (`["warning", { ... }]`). It is nil
+// when the rule was configured with a bare severity literal. Rules that
+// accept options decode the blob into their own struct via
+// `(*Context).DecodeOptions` and fall back to defaults on nil.
 type Context struct {
   File     *shimast.SourceFile
   Checker  *shimchecker.Checker
   Severity Severity
+  Options  json.RawMessage
 
-  rule    Rule
-  collect func(*Finding)
+  rule     Rule
+  isFormat bool
+  collect  func(*Finding)
+}
+
+// DecodeOptions unmarshals the rule's options blob into `out`. Returns
+// nil with no side effect when the rule was configured with severity
+// alone, so callers can write
+//
+//  var opts myRuleOptions
+//  ctx.DecodeOptions(&opts)
+//  // opts now holds either the user's settings or the zero value.
+func (c *Context) DecodeOptions(out interface{}) error {
+  if c == nil || len(c.Options) == 0 {
+    return nil
+  }
+  return json.Unmarshal(c.Options, out)
 }
 
 // Finding is one rule-emitted diagnostic before it gets converted into a
-// driver Diagnostic.
+// driver Diagnostic. `IsFormat` mirrors the dispatching rule's category
+// so the `format` subcommand's filter can route findings without
+// re-querying the registry. The `fix` subcommand applies findings from
+// both categories — no filter — because `ttsc fix` is the
+// run-everything entry point.
 type Finding struct {
   Rule     string
   Severity Severity
@@ -62,6 +113,17 @@ type Finding struct {
   Pos      int
   End      int
   Message  string
+  Fix      []TextEdit
+  IsFormat bool
+}
+
+// TextEdit is one byte-range replacement offered by an autofixable finding.
+// Positions use the same byte offsets as shim AST nodes and must point inside
+// the finding's source file.
+type TextEdit struct {
+  Pos  int
+  End  int
+  Text string
 }
 
 // Report records a finding at the given node's source range. The pos is
@@ -71,6 +133,11 @@ type Finding struct {
 // configured severity is `off` (defensive — the engine already filters
 // by severity before calling Check, but Report is the final gate).
 func (c *Context) Report(node *shimast.Node, message string) {
+  c.ReportFix(node, message)
+}
+
+// ReportFix records a node-scoped finding with optional autofix edits.
+func (c *Context) ReportFix(node *shimast.Node, message string, edits ...TextEdit) {
   if c.Severity == SeverityOff || node == nil {
     return
   }
@@ -85,6 +152,8 @@ func (c *Context) Report(node *shimast.Node, message string) {
     Pos:      pos,
     End:      node.End(),
     Message:  message,
+    Fix:      cloneTextEdits(edits),
+    IsFormat: c.isFormat,
   })
 }
 
@@ -92,6 +161,11 @@ func (c *Context) Report(node *shimast.Node, message string) {
 // current file. Use this when the rule wants to highlight a sub-token of
 // a node (e.g. an operator inside a BinaryExpression).
 func (c *Context) ReportRange(pos, end int, message string) {
+  c.ReportRangeFix(pos, end, message)
+}
+
+// ReportRangeFix records an explicit-range finding with optional autofix edits.
+func (c *Context) ReportRangeFix(pos, end int, message string, edits ...TextEdit) {
   if c.Severity == SeverityOff || c.File == nil {
     return
   }
@@ -105,9 +179,20 @@ func (c *Context) ReportRange(pos, end int, message string) {
     Pos:      pos,
     End:      end,
     Message:  message,
+    Fix:      cloneTextEdits(edits),
+    IsFormat: c.isFormat,
   })
 }
 
+func cloneTextEdits(edits []TextEdit) []TextEdit {
+  if len(edits) == 0 {
+    return nil
+  }
+  out := make([]TextEdit, len(edits))
+  copy(out, edits)
+  return out
+}
+
 // registry stores the package-global rule list keyed by name. Tests can
 // also reach into it via `LookupRule`.
 type registry struct {
@@ -178,7 +263,14 @@ func NewEngineWithResolver(config RuleResolver) *Engine {
       continue
     }
     eng.enabled[name] = displaySeverities.Severity(name)
+    // Dedup kinds per rule so a contributor that accidentally lists the
+    // same Kind twice in `Visits()` doesn't end up firing twice per node.
+    seen := make(map[shimast.Kind]struct{})
     for _, kind := range rule.Visits() {
+      if _, dup := seen[kind]; dup {
+        continue
+      }
+      seen[kind] = struct{}{}
       eng.rules[kind] = append(eng.rules[kind], rule)
     }
   }
@@ -234,10 +326,12 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
           File:     file,
           Checker:  checker,
           Severity: severity,
+          Options:  e.config.RuleOptions(rule.Name()),
           rule:     rule,
+          isFormat: isFormatRule(rule),
           collect:  collect,
         }
-        rule.Check(ctx, node)
+        runRuleCheck(rule, ctx, node, collect)
       }
     }
     node.ForEachChild(func(child *shimast.Node) bool {
@@ -260,19 +354,70 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
         File:     file,
         Checker:  checker,
         Severity: severity,
+        Options:  e.config.RuleOptions(rule.Name()),
         rule:     rule,
+        isFormat: isFormatRule(rule),
         collect:  collect,
       }
-      rule.Check(ctx, file.AsNode())
+      runRuleCheck(rule, ctx, file.AsNode(), collect)
     }
   }
 
   statements := file.Statements
-  if statements == nil {
-    return collected
-  }
-  for _, stmt := range statements.Nodes {
-    walk(stmt)
+  if statements != nil {
+    for _, stmt := range statements.Nodes {
+      walk(stmt)
+    }
   }
+  // 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)
 }
+
+// runRuleCheck invokes a rule's `Check` with a `recover()` barrier so a
+// panicking rule does not abort the entire `ttsc fix` / `ttsc check`
+// run. Built-in rules are not expected to panic, but contributor rules
+// crossing into the public `rule.Context` adapter can be authored by
+// anyone; protecting the engine is the only way to bound the blast
+// radius of one bad rule. The recovered panic is surfaced as a
+// SeverityError finding tagged with the rule's name so the user sees
+// the failure in the normal diagnostic stream.
+func runRuleCheck(rule Rule, ctx *Context, node *shimast.Node, collect func(*Finding)) {
+  defer func() {
+    r := recover()
+    if r == nil {
+      return
+    }
+    if ctx == nil || ctx.File == nil {
+      // Without source context there is nowhere to anchor the
+      // diagnostic. Surface to stderr so the panic is at least
+      // visible to the operator.
+      fmt.Fprintf(os.Stderr, "@ttsc/lint: rule %q panicked: %v\n", rule.Name(), r)
+      return
+    }
+    pos := 0
+    end := 1
+    if node != nil {
+      pos = node.Pos()
+      end = node.End()
+    }
+    if end <= pos {
+      end = pos + 1
+    }
+    collect(&Finding{
+      Rule:     rule.Name(),
+      Severity: SeverityError,
+      Pos:      pos,
+      End:      end,
+      Message: fmt.Sprintf(
+        "Rule %q panicked while checking this node: %v. Report this to the rule's author; ttsc skipped the rule on this file.",
+        rule.Name(), r,
+      ),
+      File: ctx.File,
+    })
+  }()
+  rule.Check(ctx, node)
+}

package/{plugin → linthost}/eslint_runtime.go

@@ -1,4 +1,4 @@
-package main
+package linthost
 
 import (
   "encoding/json"
@@ -21,6 +21,7 @@ type eslintRuntimeProvider interface {
 
 type eslintRuntimeOutput struct {
   Missing bool                `json:"missing"`
+  Fixed   int                 `json:"fixed"`
   Results []eslintRuntimeFile `json:"results"`
 }
 
@@ -126,11 +127,69 @@ func runExternalESLintDiagnostics(
 }
 
 func runExternalESLint(cwd, configPath, fileListJSON string) (*eslintRuntimeOutput, error) {
+  return runExternalESLintWithMode(cwd, configPath, fileListJSON, false)
+}
+
+func runExternalESLintFixes(
+  resolver RuleResolver,
+  cwd string,
+  files []*shimast.SourceFile,
+) (int, error) {
+  provider, ok := resolver.(eslintRuntimeProvider)
+  if !ok || !provider.WantsESLintRuntime() {
+    return 0, nil
+  }
+  configPath := provider.ExternalConfigPath()
+  if configPath == "" {
+    return 0, nil
+  }
+
+  fileNames := make([]string, 0, len(files))
+  for _, file := range files {
+    if file == nil || file.IsDeclarationFile {
+      continue
+    }
+    name := file.FileName()
+    if !filepath.IsAbs(name) {
+      name = filepath.Join(cwd, name)
+    }
+    if abs, err := filepath.Abs(name); err == nil {
+      name = abs
+    }
+    fileNames = append(fileNames, name)
+  }
+  if len(fileNames) == 0 {
+    return 0, nil
+  }
+
+  payload, err := json.Marshal(fileNames)
+  if err != nil {
+    return 0, fmt.Errorf("@ttsc/lint: encode ESLint file list: %w", err)
+  }
+
+  output, err := runExternalESLintWithMode(cwd, configPath, string(payload), true)
+  if err != nil {
+    return 0, err
+  }
+  if output.Missing {
+    if provider.RequiresESLintRuntime() {
+      return 0, fmt.Errorf("@ttsc/lint: ESLint runtime is required by %s; install eslint in the project or replace runtime-only config features", configPath)
+    }
+    return 0, nil
+  }
+  return output.Fixed, nil
+}
+
+func runExternalESLintWithMode(cwd, configPath, fileListJSON string, fix bool) (*eslintRuntimeOutput, error) {
   node := os.Getenv("TTSC_NODE_BINARY")
   if node == "" {
     node = "node"
   }
-  cmd := exec.Command(node, "-e", externalESLintRunnerScript, cwd, configPath, fileListJSON)
+  mode := "check"
+  if fix {
+    mode = "fix"
+  }
+  cmd := exec.Command(node, "-e", externalESLintRunnerScript, cwd, configPath, fileListJSON, mode)
   cmd.Env = nodeConfigLoaderEnv(configPath)
   cmd.Dir = cwd
   raw, err := cmd.Output()
@@ -196,6 +255,7 @@ const path = require("node:path");
   const cwd = process.argv[1];
   const configPath = process.argv[2];
   const files = JSON.parse(process.argv[3]);
+  const shouldFix = process.argv[4] === "fix";
   const requireFromProject = createRequire(path.join(cwd, "package.json"));
   let eslintPath;
   try {
@@ -220,12 +280,26 @@ const path = require("node:path");
   const eslint = new ESLintCtor({
     cwd,
     overrideConfigFile: configPath,
+    fix: shouldFix,
     ignore: true,
     warnIgnored: false,
   });
   const results = await eslint.lintFiles(files);
+  if (shouldFix) {
+    const outputFixes =
+      ESLintCtor.outputFixes ||
+      eslintModule.ESLint?.outputFixes ||
+      eslintModule.default?.ESLint?.outputFixes;
+    if (typeof outputFixes !== "function") {
+      throw new Error("installed eslint package does not expose ESLint.outputFixes");
+    }
+    await outputFixes.call(ESLintCtor, results);
+  }
   process.stdout.write(JSON.stringify({
     missing: false,
+    fixed: shouldFix
+      ? results.filter((result) => typeof result.output === "string").length
+      : 0,
     results: results.map((result) => ({
       filePath: result.filePath,
       messages: result.messages.map((message) => ({

package/linthost/fix.go

@@ -0,0 +1,249 @@
+package linthost
+
+import (
+  "fmt"
+  "os"
+  "path/filepath"
+  "sort"
+
+  shimdw "github.com/microsoft/typescript-go/shim/diagnosticwriter"
+)
+
+// maxFixPasses bounds the native cascade after the one-shot ESLint runtime
+// pass. Real-world cascades (no-var → prefer-const → 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
+
+// RunFix implements `@ttsc/lint fix` — apply autofixes, then report any
+// remaining type or lint diagnostics without emitting JavaScript.
+func RunFix(args []string) int {
+  opts, err := parseSubcommandFlags("fix", args)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  if opts.emit {
+    fmt.Fprintln(os.Stderr, "@ttsc/lint fix: --emit is not supported")
+    return 2
+  }
+  opts.noEmit = true
+  return runFix(opts)
+}
+
+func runFix(opts *subcommandOpts) int {
+  rules, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+
+  prog, code := loadFixProgram(opts)
+  if code != 0 {
+    return code
+  }
+  defer func() {
+    if prog != nil {
+      prog.close()
+    }
+  }()
+
+  totalFixes := 0
+  if fixed, err := runExternalESLintFixes(rules, opts.cwd, prog.userSourceFiles()); err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  } else if fixed > 0 {
+    totalFixes += fixed
+    prog, code = reloadFixProgram(prog, opts)
+    if code != 0 {
+      return code
+    }
+  }
+
+  // `ttsc fix` applies edits from BOTH lint-class rules and
+  // format-class rules. The dual `ttsc format` subcommand exists for
+  // the format-only path; fix is the "run everything" entry point so
+  // users don't have to chain two invocations. The engine emits both
+  // kinds of findings in one pass — no filtering needed here.
+  cascadeConverged := false
+  for pass := 0; pass < maxFixPasses; pass++ {
+    engine := NewEngineWithResolver(rules)
+    findings := engine.Run(prog.userSourceFiles(), prog.checker)
+    fixed, err := applyFindingFixes(opts.cwd, findings)
+    if err != nil {
+      fmt.Fprintln(os.Stderr, err)
+      return 3
+    }
+    if fixed == 0 {
+      cascadeConverged = true
+      break
+    }
+    totalFixes += fixed
+    prog, code = reloadFixProgram(prog, opts)
+    if code != 0 {
+      return code
+    }
+  }
+  if !cascadeConverged {
+    // A non-converged exit means at least one rule kept emitting
+    // edits on every pass — typically a buggy fixer that doesn't
+    // settle the diagnostic it produces. The remaining findings still
+    // surface below as ordinary diagnostics, and the exit code below
+    // is bumped to 2 so a CI gate like `ttsc fix && echo ok` does not
+    // silently accept the buggy-fixer state.
+    fmt.Fprintf(os.Stderr,
+      "@ttsc/lint: fix cascade did not converge after %d passes; remaining diagnostics are reported below\n",
+      maxFixPasses)
+  }
+
+  engine := NewEngineWithResolver(rules)
+  astDiags, lintDiags, externalRan, err := collectDiagnostics(prog, engine)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  if !externalRan {
+    warnUnknownRules(os.Stderr, engine.UnknownRules())
+  }
+  errCount := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, opts.cwd)
+  if errCount > 0 {
+    return 2
+  }
+  if !cascadeConverged {
+    // Diagnostics may all be warnings (or empty) yet the cascade did
+    // not settle — surface the failure as exit 2 so the warning above
+    // is not lost in a shell `&& echo ok` pipeline.
+    return 2
+  }
+  if opts.verbose && totalFixes > 0 {
+    fmt.Fprintf(os.Stdout, "@ttsc/lint: fixed=%d edits\n", totalFixes)
+  }
+  return 0
+}
+
+func loadFixProgram(opts *subcommandOpts) (*program, int) {
+  prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
+    forceNoEmit: true,
+    outDir:      opts.outDir,
+  })
+  if err != nil {
+    fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
+    return nil, 2
+  }
+  if len(parseDiags) > 0 {
+    shimdw.FormatASTDiagnosticsWithColorAndContext(os.Stderr, parseDiags, opts.cwd)
+    return nil, 2
+  }
+  return prog, 0
+}
+
+func reloadFixProgram(current *program, opts *subcommandOpts) (*program, int) {
+  if current != nil {
+    current.close()
+  }
+  return loadFixProgram(opts)
+}
+
+type fileFixes struct {
+  path  string
+  text  string
+  edits []TextEdit
+}
+
+func applyFindingFixes(cwd string, findings []*Finding) (int, error) {
+  byFile := map[string]*fileFixes{}
+  for _, finding := range findings {
+    if finding == nil || finding.File == nil || len(finding.Fix) == 0 {
+      continue
+    }
+    path := finding.File.FileName()
+    if path == "" {
+      continue
+    }
+    if !filepath.IsAbs(path) {
+      path = filepath.Join(cwd, path)
+    }
+    if abs, err := filepath.Abs(path); err == nil {
+      path = abs
+    }
+    bucket := byFile[path]
+    if bucket == nil {
+      bucket = &fileFixes{path: path, text: finding.File.Text()}
+      byFile[path] = bucket
+    }
+    bucket.edits = append(bucket.edits, finding.Fix...)
+  }
+
+  paths := make([]string, 0, len(byFile))
+  for p := range byFile {
+    paths = append(paths, p)
+  }
+  sort.Strings(paths)
+  total := 0
+  for _, p := range paths {
+    bucket := byFile[p]
+    fixed, err := applyTextEditsToFile(bucket.path, bucket.text, bucket.edits)
+    if err != nil {
+      return total, err
+    }
+    total += fixed
+  }
+  return total, nil
+}
+
+func applyTextEditsToFile(path, source string, edits []TextEdit) (int, error) {
+  selected := selectTextEdits(len(source), edits)
+  if len(selected) == 0 {
+    return 0, nil
+  }
+  next := source
+  for i := len(selected) - 1; i >= 0; i-- {
+    edit := selected[i]
+    next = next[:edit.Pos] + edit.Text + next[edit.End:]
+  }
+  if next == source {
+    return 0, nil
+  }
+  if err := os.WriteFile(path, []byte(next), 0o644); err != nil {
+    return 0, fmt.Errorf("@ttsc/lint fix: write %s: %w", path, err)
+  }
+  return len(selected), nil
+}
+
+func selectTextEdits(sourceLen int, edits []TextEdit) []TextEdit {
+  if len(edits) == 0 {
+    return nil
+  }
+  sorted := make([]TextEdit, 0, len(edits))
+  seen := map[TextEdit]struct{}{}
+  for _, edit := range edits {
+    if edit.Pos < 0 || edit.End < edit.Pos || edit.End > sourceLen {
+      continue
+    }
+    if _, exists := seen[edit]; exists {
+      continue
+    }
+    seen[edit] = struct{}{}
+    sorted = append(sorted, edit)
+  }
+  sort.SliceStable(sorted, func(i, j int) bool {
+    if sorted[i].Pos != sorted[j].Pos {
+      return sorted[i].Pos < sorted[j].Pos
+    }
+    if sorted[i].End != sorted[j].End {
+      return sorted[i].End < sorted[j].End
+    }
+    return sorted[i].Text < sorted[j].Text
+  })
+
+  selected := make([]TextEdit, 0, len(sorted))
+  lastEnd := -1
+  for _, edit := range sorted {
+    if edit.Pos < lastEnd {
+      continue
+    }
+    selected = append(selected, edit)
+    lastEnd = edit.End
+  }
+  return selected
+}