@ttsc/lint 0.12.3 → 0.13.0

package/linthost/compile.go

@@ -13,6 +13,7 @@ package linthost
 
 import (
   "context"
+  "encoding/json"
   "errors"
   "flag"
   "fmt"
@@ -59,26 +60,40 @@ func RunTransform(args []string) int {
   tsconfig := fs.String("tsconfig", "tsconfig.json", "tsconfig owning --file")
   cwd := fs.String("cwd", "", "override the working directory")
   pluginsJSON := fs.String("plugins-json", "", "ttsc plugin manifest JSON")
-  if err := fs.Parse(filterKnownFlags(args, map[string]bool{
-    "cwd":          true,
-    "file":         true,
-    "out":          true,
-    "plugins-json": true,
-    "tsconfig":     true,
-  })); err != nil {
+  singleThreaded := fs.Bool("singleThreaded", false, "run TypeScript-Go single-threaded")
+  checkers := fs.Int("checkers", 0, "type-checker pool size (0 = TypeScript-Go default)")
+  tsgoArgsRaw := fs.String("tsgo-args", "", "JSON array of forwarded tsgo CLI flags")
+  if err := fs.Parse(filterKnownFlags(args, LintFlagAllowList)); err != nil {
     return 2
   }
   if *file == "" {
     fmt.Fprintln(os.Stderr, "@ttsc/lint transform: --file is required")
     return 2
   }
+  tsgoArgs, err := decodeTsgoArgs(*tsgoArgsRaw)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
   resolvedCwd, err := resolveCwd(*cwd)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
+  rules, err := loadRules(*pluginsJSON, resolvedCwd, *tsconfig)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  engine := NewEngineWithResolver(rules)
+  engine.SetSerial(*singleThreaded)
+
   prog, parseDiags, err := loadProgram(resolvedCwd, *tsconfig, loadProgramOptions{
-    forceEmit: true,
+    forceEmit:        true,
+    needsRuleChecker: engine.NeedsTypeChecker(),
+    singleThreaded:   *singleThreaded,
+    checkers:         *checkers,
+    tsgoArgs:         tsgoArgs,
   })
   if err != nil {
     fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
@@ -90,21 +105,12 @@ func RunTransform(args []string) int {
   }
   defer prog.close()
 
-  rules, err := loadRules(*pluginsJSON, resolvedCwd, *tsconfig)
-  if err != nil {
-    fmt.Fprintln(os.Stderr, err)
-    return 2
-  }
-  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())
   if errors := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, resolvedCwd); errors > 0 {
     return 2
   }
@@ -158,16 +164,22 @@ func RunTransform(args []string) int {
 }
 
 type subcommandOpts struct {
-  cwd         string
-  tsconfig    string
-  pluginsJSON string
-  emit        bool
-  noEmit      bool
-  quiet       bool
-  verbose     bool
-  outDir      string
+  cwd            string
+  tsconfig       string
+  pluginsJSON    string
+  emit           bool
+  noEmit         bool
+  quiet          bool
+  verbose        bool
+  outDir         string
+  singleThreaded bool
+  checkers       int
+  tsgoArgs       []string
 }
 
+// parseSubcommandFlags parses the shared flag set used by the `check`,
+// `build`, and `fix`/`format` subcommands. Unknown flags are silently
+// stripped by `filterKnownFlags` before the standard FlagSet sees them.
 func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
   fs := flag.NewFlagSet(name, flag.ContinueOnError)
   fs.SetOutput(os.Stderr)
@@ -179,42 +191,72 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
   quiet := fs.Bool("quiet", false, "")
   verbose := fs.Bool("verbose", false, "")
   outDir := fs.String("outDir", "", "")
-  if err := fs.Parse(filterKnownFlags(args, map[string]bool{
-    "cwd":          true,
-    "emit":         false,
-    "noEmit":       false,
-    "outDir":       true,
-    "plugins-json": true,
-    "quiet":        false,
-    "tsconfig":     true,
-    "verbose":      false,
-  })); err != nil {
+  singleThreaded := fs.Bool("singleThreaded", false, "")
+  checkers := fs.Int("checkers", 0, "")
+  tsgoArgsRaw := fs.String("tsgo-args", "", "")
+  if err := fs.Parse(filterKnownFlags(args, LintFlagAllowList)); err != nil {
     return nil, err
   }
   if *emit && *noEmit {
     return nil, errors.New("@ttsc/lint: --emit and --noEmit are mutually exclusive")
   }
+  tsgoArgs, err := decodeTsgoArgs(*tsgoArgsRaw)
+  if err != nil {
+    return nil, err
+  }
   resolvedCwd, err := resolveCwd(*cwd)
   if err != nil {
     return nil, err
   }
   return &subcommandOpts{
-    cwd:         resolvedCwd,
-    tsconfig:    *tsconfig,
-    pluginsJSON: *pluginsJSON,
-    emit:        *emit,
-    noEmit:      *noEmit,
-    quiet:       *quiet,
-    verbose:     *verbose,
-    outDir:      *outDir,
+    cwd:            resolvedCwd,
+    tsconfig:       *tsconfig,
+    pluginsJSON:    *pluginsJSON,
+    emit:           *emit,
+    noEmit:         *noEmit,
+    quiet:          *quiet,
+    verbose:        *verbose,
+    outDir:         *outDir,
+    singleThreaded: *singleThreaded,
+    checkers:       *checkers,
+    tsgoArgs:       tsgoArgs,
   }, nil
 }
 
+// decodeTsgoArgs decodes the JSON-array value of the `--tsgo-args` flag — the
+// tsgo CLI flags the `ttsc` launcher forwarded — into a string slice. An empty
+// flag yields a nil slice.
+func decodeTsgoArgs(raw string) ([]string, error) {
+  if raw == "" {
+    return nil, nil
+  }
+  var args []string
+  if err := json.Unmarshal([]byte(raw), &args); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: invalid --tsgo-args: %w", err)
+  }
+  return args, nil
+}
+
+// runProject is the shared body of RunCheck and RunBuild. It loads the
+// program, collects diagnostics, renders them, and optionally emits
+// JavaScript output when the config allows it.
 func runProject(opts *subcommandOpts) int {
+  rules, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  engine := NewEngineWithResolver(rules)
+  engine.SetSerial(opts.singleThreaded)
+
   prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
-    forceEmit:   opts.emit,
-    forceNoEmit: opts.noEmit,
-    outDir:      opts.outDir,
+    forceEmit:        opts.emit,
+    forceNoEmit:      opts.noEmit,
+    outDir:           opts.outDir,
+    needsRuleChecker: engine.NeedsTypeChecker(),
+    singleThreaded:   opts.singleThreaded,
+    checkers:         opts.checkers,
+    tsgoArgs:         opts.tsgoArgs,
   })
   if err != nil {
     fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
@@ -226,21 +268,12 @@ func runProject(opts *subcommandOpts) int {
   }
   defer prog.close()
 
-  rules, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
-  if err != nil {
-    fmt.Fprintln(os.Stderr, err)
-    return 2
-  }
-  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())
   if errCount := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, opts.cwd); errCount > 0 {
     return 2
   }
@@ -273,6 +306,9 @@ func runProject(opts *subcommandOpts) int {
   return 0
 }
 
+// loadRules decodes `--plugins-json`, locates the `@ttsc/lint` entry, and
+// returns its resolved RuleResolver. Returns an empty RuleConfig (no rules
+// enabled) when the lint entry is absent from the plugin manifest.
 func loadRules(pluginsJSON, cwd, tsconfigPath string) (RuleResolver, error) {
   entries, err := ParsePlugins(pluginsJSON)
   if err != nil {
@@ -288,12 +324,22 @@ func loadRules(pluginsJSON, cwd, tsconfigPath string) (RuleResolver, error) {
   return LoadConfigResolver(entry, cwd, tsconfigPath)
 }
 
+// warnUnknownRules writes one warning line per name in `unknown` to `w`.
+// Called after engine construction so a config that names a rule the native
+// engine does not implement surfaces a loud warning instead of silently
+// linting nothing for that rule.
 func warnUnknownRules(w io.Writer, unknown []string) {
   for _, name := range unknown {
     fmt.Fprintf(w, "@ttsc/lint: ignoring unknown rule %q\n", name)
   }
 }
 
+// filterKnownFlags strips flags from `args` that are not present in `known`.
+// The `known` map value is true when the flag takes a separate value token
+// (e.g. `--tsconfig tsconfig.json`) and false for boolean flags. Unknown
+// flags are silently dropped along with their value token when present.
+// This lets the host forward a superset of flags without confusing the
+// standard library's FlagSet.
 func filterKnownFlags(args []string, known map[string]bool) []string {
   out := make([]string, 0, len(args))
   for i := 0; i < len(args); i++ {
@@ -326,7 +372,7 @@ func filterKnownFlags(args []string, known map[string]bool) []string {
 // collectDiagnostics merges tsgo typecheck diagnostics with the lint
 // engine's findings. The renderer takes the two slices and walks them in
 // source order, so we don't need to interleave here.
-func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, []*shimdw.LintDiagnostic, bool, error) {
+func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, []*shimdw.LintDiagnostic, error) {
   astDiags := prog.programDiagnostics()
   files := prog.userSourceFiles()
   findings := engine.Run(files, prog.checker)
@@ -345,58 +391,7 @@ func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, [
       fmt.Sprintf("[%s] %s", finding.Rule, finding.Message),
     ))
   }
-  if externalDiags, ran, err := runExternalESLintDiagnostics(engine.config, prog.cwd, files); err != nil {
-    return nil, nil, false, err
-  } else if ran {
-    return astDiags, mergeNativeAndExternalDiagnostics(nativeDiags, externalDiags), true, nil
-  }
-  return astDiags, nativeDiags, false, nil
-}
-
-func mergeNativeAndExternalDiagnostics(nativeDiags, externalDiags []*shimdw.LintDiagnostic) []*shimdw.LintDiagnostic {
-  if len(nativeDiags) == 0 {
-    return externalDiags
-  }
-  if len(externalDiags) == 0 {
-    return nativeDiags
-  }
-  externalRules := make(map[string]struct{})
-  for _, diag := range externalDiags {
-    if rule := canonicalLintRule(lintDiagnosticRule(diag)); rule != "" {
-      externalRules[rule] = struct{}{}
-    }
-  }
-  out := make([]*shimdw.LintDiagnostic, 0, len(nativeDiags)+len(externalDiags))
-  for _, diag := range nativeDiags {
-    rule := canonicalLintRule(lintDiagnosticRule(diag))
-    if _, exists := externalRules[rule]; rule != "" && exists {
-      continue
-    }
-    out = append(out, diag)
-  }
-  return append(out, externalDiags...)
-}
-
-func lintDiagnosticRule(diag *shimdw.LintDiagnostic) string {
-  if diag == nil {
-    return ""
-  }
-  message := diag.Message()
-  if !strings.HasPrefix(message, "[") {
-    return ""
-  }
-  end := strings.Index(message, "]")
-  if end <= 1 {
-    return ""
-  }
-  return message[1:end]
-}
-
-func canonicalLintRule(rule string) string {
-  rule = strings.TrimSpace(rule)
-  rule = strings.TrimPrefix(rule, "@typescript-eslint/")
-  rule = strings.TrimPrefix(rule, "typescript-eslint/")
-  return rule
+  return astDiags, nativeDiags, nil
 }
 
 // RuleCode hashes a rule name into a stable, positive int32 so the
@@ -417,6 +412,9 @@ func RuleCode(name string) int32 {
 // that prefer the lowercase form.
 func ruleCode(name string) int32 { return RuleCode(name) }
 
+// resolveCwd returns an absolute working directory. When `override` is
+// non-empty it is made absolute; otherwise the process working directory
+// is returned.
 func resolveCwd(override string) (string, error) {
   if override != "" {
     abs, err := filepath.Abs(override)
@@ -432,6 +430,9 @@ func resolveCwd(override string) (string, error) {
   return wd, nil
 }
 
+// isJavaScriptOutput reports whether `name` has a JavaScript output
+// extension (.js, .mjs, or .cjs). Used to filter the emit callback so
+// that `RunTransform` captures only the JS output for the target file.
 func isJavaScriptOutput(name string) bool {
   switch strings.ToLower(filepath.Ext(name)) {
   case ".js", ".mjs", ".cjs":
@@ -441,6 +442,9 @@ func isJavaScriptOutput(name string) bool {
   }
 }
 
+// defaultWriteFile creates all parent directories and writes `text` to
+// `name` with mode 0644. Used as the WriteFile callback in `runProject`
+// when the user requested emit.
 func defaultWriteFile(name string, text string) error {
   if err := os.MkdirAll(filepath.Dir(name), 0o755); err != nil {
     return err