@ttsc/lint 0.12.4 → 0.13.1

package/linthost/config_format.go

@@ -10,9 +10,8 @@ import (
 // The result is a `map[string]any` that mirrors what a user would
 // have written under `rules` directly — entries like
 // `"format/semi": ["off", {"prefer": "always"}]` — so the caller
-// can route it through either `ParseRulesWithOptions` (inline path) or
-// `parseExternalRuleMapInto` (flat-config path) without duplicating
-// option-decoding logic.
+// can route it through either `ParseRulesWithOptions` or
+// `parseExternalRuleMapInto` without duplicating option-decoding logic.
 //
 // The block's default severity is off. That keeps check/build diagnostics
 // independent from formatting policy unless the user explicitly sets
@@ -91,12 +90,22 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
   out["format/trailing-comma"] = ruleEntry(map[string]any{"mode": tcMode})
 
   // format/print-width
-  pwOpts := map[string]any{}
+  //
+  // `trailingComma` is mirrored into the print-width rule's options so
+  // the printer's broken-list reflow emits the same trailing-comma
+  // shape `format/trailing-comma` does. Without the mirror the two
+  // rules disagree on `es5` / `none` projects and oscillate on every
+  // cascade pass — the trailing-comma rule says "no comma" while the
+  // printer adds one back. See `printArgList` in print_nodes_call.go.
+  pwOpts := map[string]any{"trailingComma": tcMode}
   if v, ok := raw["printWidth"]; ok {
     n, err := asInt("format.printWidth", v)
     if err != nil {
       return nil, err
     }
+    if n < 1 {
+      return nil, fmt.Errorf("@ttsc/lint: format.printWidth must be a positive integer; got %d", n)
+    }
     pwOpts["printWidth"] = n
   }
   if v, ok := raw["tabWidth"]; ok {
@@ -104,6 +113,9 @@ func expandFormatBlock(raw map[string]any) (map[string]any, error) {
     if err != nil {
       return nil, err
     }
+    if n < 1 {
+      return nil, fmt.Errorf("@ttsc/lint: format.tabWidth must be a positive integer; got %d", n)
+    }
     pwOpts["tabWidth"] = n
   }
   if v, ok := raw["useTabs"]; ok {

package/linthost/contrib_adapter.go

@@ -68,6 +68,13 @@ type contributorAdapter struct {
   inner rule.Rule
 }
 
+// NeedsTypeChecker keeps contributor rules on the historical checker path.
+// The public rule.Context exposes Checker and has no mandatory marker, so the
+// host cannot safely infer that a third-party rule is AST-only.
+func (a contributorAdapter) NeedsTypeChecker() bool {
+  return true
+}
+
 // formatContributorAdapter is the FormatRule-tagged variant of
 // contributorAdapter. Wrapping the lint-only adapter (rather than
 // duplicating its method set) keeps the marker addition trivial and

package/linthost/directives.go

@@ -95,6 +95,18 @@ func filterInlineDisabledFindings(file *shimast.SourceFile, findings []*Finding)
 // parseLintInlineDirectives scans all comment tokens in `file` for
 // recognized directive markers and returns a structured summary of the
 // per-line and range-style suppressions found.
+//
+// The raw scanner does not split `KindTemplateExpression` on its own:
+// after returning `KindTemplateHead`/`KindTemplateMiddle`, it resumes
+// lexing the substitution as ordinary code, and a later `}` is reported
+// as `KindCloseBraceToken` instead of re-entering the template body.
+// Without intervention the next backtick would open a fresh template
+// scan that swallows the rest of the file (including every disable
+// directive comment) as one runaway unterminated literal. The parser
+// avoids this by calling `ReScanTemplateToken` on the matching `}`;
+// this loop mirrors that behavior with a brace-depth stack so comment
+// positions stay aligned with the source bytes past any template
+// substitution.
 func parseLintInlineDirectives(file *shimast.SourceFile) *lintInlineDirectives {
   directives := &lintInlineDirectives{
     lines: make(map[int][]lintDirectiveRules),
@@ -103,12 +115,44 @@ func parseLintInlineDirectives(file *shimast.SourceFile) *lintInlineDirectives {
   scanner.SetText(file.Text())
   scanner.SetSkipTrivia(false)
 
+  // templateBraceDepth tracks `{` nesting inside each open template
+  // substitution. A zero on top means the next `}` matches the original
+  // `${` and must be re-scanned as a template middle/tail token.
+  var templateBraceDepth []int
+
 scan:
   for {
     kind := scanner.Scan()
     switch kind {
     case shimast.KindEndOfFile:
       break scan
+    case shimast.KindTemplateHead, shimast.KindTemplateMiddle:
+      // Entering a `${...}` substitution; account for its closing `}`.
+      templateBraceDepth = append(templateBraceDepth, 0)
+      continue
+    case shimast.KindOpenBraceToken:
+      if n := len(templateBraceDepth); n > 0 {
+        templateBraceDepth[n-1]++
+      }
+      continue
+    case shimast.KindCloseBraceToken:
+      n := len(templateBraceDepth)
+      if n == 0 {
+        continue
+      }
+      if templateBraceDepth[n-1] > 0 {
+        templateBraceDepth[n-1]--
+        continue
+      }
+      // Matching `}` for the original `${`. Pop the substitution and
+      // rescan as template; a `KindTemplateMiddle` reopens a new
+      // substitution, a `KindTemplateTail` closes the template literal.
+      templateBraceDepth = templateBraceDepth[:n-1]
+      rescanned := scanner.ReScanTemplateToken(false /*isTaggedTemplate*/)
+      if rescanned == shimast.KindTemplateMiddle {
+        templateBraceDepth = append(templateBraceDepth, 0)
+      }
+      continue
     case shimast.KindSingleLineCommentTrivia, shimast.KindMultiLineCommentTrivia:
     default:
       continue

package/linthost/engine.go

@@ -21,7 +21,9 @@ import (
   "encoding/json"
   "fmt"
   "os"
+  "runtime"
   "sort"
+  "sync"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
@@ -62,12 +64,23 @@ type FormatRule interface {
   IsFormat() bool
 }
 
+// typeAwareRule marks rules that need a live TypeScript checker in Context.
+// Rules that do not implement it are assumed AST-only.
+type typeAwareRule interface {
+  NeedsTypeChecker() bool
+}
+
 // isFormatRule reports whether `r` opts into the format category.
 func isFormatRule(r Rule) bool {
   fr, ok := r.(FormatRule)
   return ok && fr.IsFormat()
 }
 
+func ruleNeedsTypeChecker(r Rule) bool {
+  tr, ok := r.(typeAwareRule)
+  return ok && tr.NeedsTypeChecker()
+}
+
 // Context is the per-(file, rule) handle the engine passes to `Check`.
 //
 // `Options` is the raw JSON blob the user wrote in their rule
@@ -234,10 +247,32 @@ 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.
 type Engine struct {
-  config  RuleResolver
-  rules   map[shimast.Kind][]Rule
-  enabled map[string]Severity
-  unknown []string
+  config           RuleResolver
+  rules            map[shimast.Kind][]Rule
+  enabled          map[string]Severity
+  unknown          []string
+  needsTypeChecker bool
+  serial           bool
+}
+
+// SetSerial forces Engine.Run to walk files one at a time. The host calls
+// this when `--singleThreaded` reaches the lint sidecar so the benchmark
+// (and any caller that wants a deterministic, low-overhead pass) can opt
+// out of file-level parallelism. Type-aware rule sets always run serial
+// regardless of this flag — the single shared checker is not concurrent —
+// so callers do not need to clear it themselves.
+func (e *Engine) SetSerial(serial bool) {
+  if e == nil {
+    return
+  }
+  e.serial = serial
+}
+
+// runsSerial reports whether Run must walk files one at a time — either
+// because the caller asked for it or because a type-aware rule pins the
+// engine to the shared single checker.
+func (e *Engine) runsSerial() bool {
+  return e == nil || e.serial || e.needsTypeChecker
 }
 
 // NewEngine returns an engine configured for `config`. Rules whose
@@ -266,6 +301,9 @@ func NewEngineWithResolver(config RuleResolver) *Engine {
       eng.unknown = append(eng.unknown, name)
       continue
     }
+    if ruleNeedsTypeChecker(rule) {
+      eng.needsTypeChecker = true
+    }
     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.
@@ -286,23 +324,75 @@ func NewEngineWithResolver(config RuleResolver) *Engine {
 // have no registered implementation.
 func (e *Engine) UnknownRules() []string { return e.unknown }
 
+// NeedsTypeChecker reports whether any active rule requires Context.Checker.
+func (e *Engine) NeedsTypeChecker() bool {
+  return e != nil && e.needsTypeChecker
+}
+
 // EnabledRules returns the active rule set keyed by name. Mostly for
 // tests + introspection.
 func (e *Engine) EnabledRules() map[string]Severity { return e.enabled }
 
-// Run walks every non-declaration source file in the program and
-// returns the collected findings.
+// Run walks the source files supplied by the caller and returns the collected
+// findings. By default files are processed in parallel, bounded by
+// `runtime.NumCPU()`; the engine falls back to a serial walk when
+// SetSerial(true) was called or when a type-aware rule is active. Findings are
+// merged in source-file order so the diagnostic stream is deterministic across
+// runs even when the per-file work happens out of order.
 func (e *Engine) Run(files []*shimast.SourceFile, checker *shimchecker.Checker) []*Finding {
-  var findings []*Finding
-  for _, file := range files {
-    if file == nil || file.IsDeclarationFile {
+  if e.runsSerial() {
+    var findings []*Finding
+    for _, file := range files {
+      if file == nil {
+        continue
+      }
+      findings = append(findings, e.runFile(file, checker)...)
+    }
+    return findings
+  }
+
+  perFile := make([][]*Finding, len(files))
+  var wg sync.WaitGroup
+  workers := runtime.NumCPU()
+  if workers < 1 {
+    workers = 1
+  }
+  sem := make(chan struct{}, workers)
+  for i, file := range files {
+    if file == nil {
       continue
     }
-    findings = append(findings, e.runFile(file, checker)...)
+    wg.Add(1)
+    sem <- struct{}{}
+    go func(idx int, f *shimast.SourceFile) {
+      defer wg.Done()
+      defer func() { <-sem }()
+      perFile[idx] = e.runFile(f, checker)
+    }(i, file)
+  }
+  wg.Wait()
+
+  total := 0
+  for _, fs := range perFile {
+    total += len(fs)
+  }
+  if total == 0 {
+    return nil
+  }
+  findings := make([]*Finding, 0, total)
+  for _, fs := range perFile {
+    findings = append(findings, fs...)
   }
   return findings
 }
 
+// boundRule pairs an active rule with the Context the engine reuses for
+// every node it dispatches to that rule within one file. See runFile.
+type boundRule struct {
+  rule Rule
+  ctx  *Context
+}
+
 // 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.
@@ -314,29 +404,53 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
     return collected
   }
   fileRules := resolved.Rules
+  if !hasEnabledFileRules(fileRules) {
+    return collected
+  }
+
+  // Bind every active rule to a Context once per file. A Context's fields
+  // — File, Checker, the file-resolved Severity, the rule's Options blob,
+  // and the format marker — are all invariant across the file's nodes, so
+  // the engine builds them here. The earlier shape allocated a fresh
+  // 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))
+  ctxByRule := make(map[string]*Context, len(e.enabled))
+  for kind, rules := range e.rules {
+    for _, rule := range rules {
+      name := rule.Name()
+      ctx, built := ctxByRule[name]
+      if !built {
+        if severity := fileRules.Severity(name); severity != SeverityOff {
+          ctx = &Context{
+            File:     file,
+            Checker:  checker,
+            Severity: severity,
+            Options:  e.config.RuleOptions(name),
+            rule:     rule,
+            isFormat: isFormatRule(rule),
+            collect:  collect,
+          }
+        }
+        // A nil entry memoizes "off for this file" so a rule registered
+        // for several kinds resolves its severity only once.
+        ctxByRule[name] = ctx
+      }
+      if ctx == nil {
+        continue
+      }
+      byKind[kind] = append(byKind[kind], boundRule{rule: rule, ctx: ctx})
+    }
+  }
 
   var walk func(node *shimast.Node)
   walk = func(node *shimast.Node) {
     if node == nil {
       return
     }
-    if rules, ok := e.rules[node.Kind]; ok {
-      for _, rule := range rules {
-        severity := fileRules.Severity(rule.Name())
-        if severity == SeverityOff {
-          continue
-        }
-        ctx := &Context{
-          File:     file,
-          Checker:  checker,
-          Severity: severity,
-          Options:  e.config.RuleOptions(rule.Name()),
-          rule:     rule,
-          isFormat: isFormatRule(rule),
-          collect:  collect,
-        }
-        runRuleCheck(rule, ctx, node, collect)
-      }
+    for _, bound := range byKind[node.Kind] {
+      runRuleCheck(bound.rule, bound.ctx, node, collect)
     }
     node.ForEachChild(func(child *shimast.Node) bool {
       walk(child)
@@ -348,23 +462,8 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
   // statements explicitly so the file node itself can be inspected by
   // rules (e.g., `ban-ts-comment` reads CommentDirectives off the
   // SourceFile).
-  if rules, ok := e.rules[shimast.KindSourceFile]; ok {
-    for _, rule := range rules {
-      severity := fileRules.Severity(rule.Name())
-      if severity == SeverityOff {
-        continue
-      }
-      ctx := &Context{
-        File:     file,
-        Checker:  checker,
-        Severity: severity,
-        Options:  e.config.RuleOptions(rule.Name()),
-        rule:     rule,
-        isFormat: isFormatRule(rule),
-        collect:  collect,
-      }
-      runRuleCheck(rule, ctx, file.AsNode(), collect)
-    }
+  for _, bound := range byKind[shimast.KindSourceFile] {
+    runRuleCheck(bound.rule, bound.ctx, file.AsNode(), collect)
   }
 
   statements := file.Statements
@@ -381,6 +480,15 @@ func (e *Engine) runFile(file *shimast.SourceFile, checker *shimchecker.Checker)
   return filterInlineDisabledFindings(file, collected)
 }
 
+func hasEnabledFileRules(rules RuleConfig) bool {
+  for _, severity := range rules {
+    if severity != SeverityOff {
+      return true
+    }
+  }
+  return false
+}
+
 // 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

package/linthost/fix.go

@@ -1,11 +1,10 @@
 // Autofix orchestration for the `@ttsc/lint fix` subcommand.
 //
-// RunFix drives the fix cascade: it applies ESLint runtime fixes first
-// (one pass, external process), then repeatedly runs the native lint
-// engine and applies any emitted TextEdit suggestions until no more
-// fixable findings remain or maxFixPasses is reached. After the cascade
-// settles, it runs a final diagnostic pass so remaining issues are
-// surfaced in the normal error stream.
+// RunFix drives the fix cascade: it repeatedly runs the native lint engine
+// and applies any emitted TextEdit suggestions until no more fixable
+// findings remain or maxFixPasses is reached. After the cascade settles, it
+// runs a final diagnostic pass so remaining issues are surfaced in the
+// normal error stream.
 package linthost
 
 import (
@@ -17,10 +16,9 @@ import (
   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.
+// maxFixPasses bounds the native fix cascade. 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
@@ -45,8 +43,11 @@ func runFix(opts *subcommandOpts) int {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
+  engine := NewEngineWithResolver(rules)
+  engine.SetSerial(opts.singleThreaded)
+  needsRuleChecker := engine.NeedsTypeChecker()
 
-  prog, code := loadFixProgram(opts)
+  prog, code := loadFixProgram(opts, needsRuleChecker)
   if code != 0 {
     return code
   }
@@ -57,16 +58,6 @@ func runFix(opts *subcommandOpts) int {
   }()
 
   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
@@ -75,7 +66,6 @@ func runFix(opts *subcommandOpts) int {
   // 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 {
@@ -87,7 +77,7 @@ func runFix(opts *subcommandOpts) int {
       break
     }
     totalFixes += fixed
-    prog, code = reloadFixProgram(prog, opts)
+    prog, code = reloadFixProgram(prog, opts, needsRuleChecker)
     if code != 0 {
       return code
     }
@@ -104,15 +94,12 @@ func runFix(opts *subcommandOpts) int {
       maxFixPasses)
   }
 
-  engine := NewEngineWithResolver(rules)
-  astDiags, lintDiags, externalRan, err := collectDiagnostics(prog, engine)
+  astDiags, lintDiags, err := collectDiagnostics(prog, engine)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
-  if !externalRan {
-    warnUnknownRules(os.Stderr, engine.UnknownRules())
-  }
+  warnUnknownRules(os.Stderr, engine.UnknownRules())
   errCount := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, opts.cwd)
   if errCount > 0 {
     return 2
@@ -131,10 +118,14 @@ func runFix(opts *subcommandOpts) int {
 
 // loadFixProgram loads the TypeScript program for a fix/format pass with
 // NoEmit forced on. Returns (nil, 2) when loading or config parsing fails.
-func loadFixProgram(opts *subcommandOpts) (*program, int) {
+func loadFixProgram(opts *subcommandOpts, needsRuleChecker bool) (*program, int) {
   prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceNoEmit: true,
-    outDir:      opts.outDir,
+    forceNoEmit:      true,
+    outDir:           opts.outDir,
+    needsRuleChecker: needsRuleChecker,
+    singleThreaded:   opts.singleThreaded,
+    checkers:         opts.checkers,
+    tsgoArgs:         opts.tsgoArgs,
   })
   if err != nil {
     fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
@@ -150,11 +141,11 @@ func loadFixProgram(opts *subcommandOpts) (*program, int) {
 // reloadFixProgram closes `current` and loads a fresh program from disk.
 // Used between cascade passes so the engine sees edits applied in the
 // previous pass rather than stale in-memory AST nodes.
-func reloadFixProgram(current *program, opts *subcommandOpts) (*program, int) {
+func reloadFixProgram(current *program, opts *subcommandOpts, needsRuleChecker bool) (*program, int) {
   if current != nil {
     current.close()
   }
-  return loadFixProgram(opts)
+  return loadFixProgram(opts, needsRuleChecker)
 }
 
 // fileFixes groups all pending TextEdit suggestions for a single file.

package/linthost/flags_gen.go

@@ -0,0 +1,33 @@
+// Code generated by packages/ttsc/scripts/gen-flags.mts. DO NOT EDIT.
+//
+// Source of truth: packages/ttsc/src/flags/schema.ts.
+// Regenerate with:    pnpm format
+// Verify in CI with:  node packages/ttsc/scripts/check-flags.cjs
+
+package linthost
+
+// LintFlagAllowList is the allow-list of CLI flags this Go layer accepts. The map's
+// value is true when the flag carries a separate value token (--flag VALUE
+// or --flag=VALUE) and false when the flag is boolean (--flag).
+//
+// Generated from packages/ttsc/src/flags/schema.ts. Edit the schema, not
+// this file.
+var LintFlagAllowList = map[string]bool{
+  "checkers":            true,
+  "cwd":                 true,
+  "diagnostics":         false,
+  "emit":                false,
+  "extendedDiagnostics": false,
+  "file":                true,
+  "noEmit":              false,
+  "out":                 true,
+  "outDir":              true,
+  "p":                   true,
+  "plugins-json":        true,
+  "project":             true,
+  "quiet":               false,
+  "singleThreaded":      false,
+  "tsconfig":            true,
+  "tsgo-args":           true,
+  "verbose":             false,
+}