@ttsc/lint 0.12.4 → 0.13.1

package/lib/structures/TtscLintRuleOptions.d.ts

@@ -89,6 +89,20 @@ export interface ITtscLintPrintWidthRuleOptions {
      * @default "lf"
      */
     endOfLine?: "lf" | "crlf";
+    /**
+     * Trailing-comma policy the reflow honors when it breaks a list across
+     * lines. Mirrors prettier's `trailingComma` and must match the
+     * `format/trailing-comma` rule's `mode`; otherwise the two rules
+     * disagree on every cascade pass and oscillate against each other.
+     *
+     * When a `format` block is configured, `format.trailingComma` is mirrored
+     * into this option automatically. Set it directly only when overriding
+     * the print-width rule via a `rules` tuple — see the conflict-resolution
+     * notes in the README.
+     *
+     * @default "all"
+     */
+    trailingComma?: "all" | "es5" | "none";
 }
 /** `format/jsdoc` rule options. */
 export interface ITtscLintJsdocRuleOptions {

package/linthost/ast_helpers.go

@@ -280,31 +280,83 @@ func walkDescendants(node *shimast.Node, visit func(*shimast.Node)) {
   })
 }
 
-// bindingIdentifierNames collects the declared identifier names from a
-// binding pattern. For a simple Identifier node it returns a single-element
-// slice. For ObjectBindingPattern and ArrayBindingPattern it walks the
-// descendants and returns all embedded Identifier texts. Returns nil for
-// unrecognized node kinds.
-func bindingIdentifierNames(node *shimast.Node) []string {
+// assignmentTargetNames collects the identifier names written by an
+// assignment's left-hand side. A bare Identifier yields one name. A
+// destructuring-assignment target — parsed as an ArrayLiteralExpression
+// (`[a, b] = …`) or ObjectLiteralExpression (`({a} = …)`) rather than a
+// binding pattern — is walked so every nested write position is counted:
+// array elements, object property values, shorthand properties, defaults
+// (`[a = 1]`, `{a = 1}`), nested patterns, and rest elements.
+//
+// Property names in `{key: target}` are read positions, not writes, so
+// only the property value contributes; member-access targets (`obj.x`)
+// declare no local binding and are skipped. Returns nil for other shapes.
+func assignmentTargetNames(node *shimast.Node) []string {
   if node == nil {
     return nil
   }
   if name := identifierText(node); name != "" {
     return []string{name}
   }
-  if node.Kind != shimast.KindObjectBindingPattern && node.Kind != shimast.KindArrayBindingPattern {
-    return nil
-  }
   var names []string
-  walkDescendants(node, func(child *shimast.Node) {
-    if child == node {
-      return
+  collectAssignmentTargetNames(node, &names)
+  return names
+}
+
+// collectAssignmentTargetNames appends to `names` every identifier in a
+// destructuring-assignment target. It descends only through write-target
+// positions so reads (object property keys, computed-member expressions)
+// never count as reassignments.
+func collectAssignmentTargetNames(node *shimast.Node, names *[]string) {
+  if node == nil {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindIdentifier:
+    if name := identifierText(node); name != "" {
+      *names = append(*names, name)
     }
-    if name := identifierText(child); name != "" {
-      names = append(names, name)
+  case shimast.KindParenthesizedExpression:
+    collectAssignmentTargetNames(stripParens(node), names)
+  case shimast.KindArrayLiteralExpression:
+    if arr := node.AsArrayLiteralExpression(); arr != nil && arr.Elements != nil {
+      for _, el := range arr.Elements.Nodes {
+        collectAssignmentTargetNames(el, names)
+      }
     }
-  })
-  return names
+  case shimast.KindObjectLiteralExpression:
+    if obj := node.AsObjectLiteralExpression(); obj != nil && obj.Properties != nil {
+      for _, prop := range obj.Properties.Nodes {
+        collectAssignmentTargetNames(prop, names)
+      }
+    }
+  case shimast.KindSpreadElement:
+    if spread := node.AsSpreadElement(); spread != nil {
+      collectAssignmentTargetNames(spread.Expression, names)
+    }
+  case shimast.KindSpreadAssignment:
+    if spread := node.AsSpreadAssignment(); spread != nil {
+      collectAssignmentTargetNames(spread.Expression, names)
+    }
+  case shimast.KindShorthandPropertyAssignment:
+    // `{a}` and `{a = 1}` — the property name is the write target; any
+    // ObjectAssignmentInitializer is a default value, not a target.
+    if short := node.AsShorthandPropertyAssignment(); short != nil {
+      collectAssignmentTargetNames(short.Name(), names)
+    }
+  case shimast.KindPropertyAssignment:
+    // `{key: target}` — only the value (initializer) is written to.
+    if assignment := node.AsPropertyAssignment(); assignment != nil {
+      collectAssignmentTargetNames(assignment.Initializer, names)
+    }
+  case shimast.KindBinaryExpression:
+    // A default inside a pattern (`[a = 1]`, `{key: a = 1}`) parses as an
+    // `=` BinaryExpression; only its left side is the write target.
+    if expr := node.AsBinaryExpression(); expr != nil &&
+      expr.OperatorToken != nil && expr.OperatorToken.Kind == shimast.KindEqualsToken {
+      collectAssignmentTargetNames(expr.Left, names)
+    }
+  }
 }
 
 // isLiteralLike reports whether `node` (after stripping parentheses) is a

package/linthost/compile.go

@@ -13,6 +13,7 @@ package linthost
 
 import (
   "context"
+  "encoding/json"
   "errors"
   "flag"
   "fmt"
@@ -20,6 +21,7 @@ import (
   "os"
   "path/filepath"
   "strings"
+  "time"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
@@ -59,26 +61,42 @@ 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")
+  _ = fs.Bool("diagnostics", false, "print @ttsc/lint diagnostics timing")
+  _ = fs.Bool("extendedDiagnostics", false, "print @ttsc/lint diagnostics timing")
+  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 +108,12 @@ func RunTransform(args []string) int {
   }
   defer prog.close()
 
-  rules, err := loadRules(*pluginsJSON, resolvedCwd, *tsconfig)
+  astDiags, lintDiags, err := collectDiagnostics(prog, engine)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
-  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())
-  }
+  warnUnknownRules(os.Stderr, engine.UnknownRules())
   if errors := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, resolvedCwd); errors > 0 {
     return 2
   }
@@ -158,14 +167,18 @@ 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
+  diagnostics    bool
+  outDir         string
+  singleThreaded bool
+  checkers       int
+  tsgoArgs       []string
 }
 
 // parseSubcommandFlags parses the shared flag set used by the `check`,
@@ -181,46 +194,76 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
   noEmit := fs.Bool("noEmit", false, "")
   quiet := fs.Bool("quiet", false, "")
   verbose := fs.Bool("verbose", false, "")
+  diagnostics := fs.Bool("diagnostics", false, "")
+  extendedDiagnostics := fs.Bool("extendedDiagnostics", 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,
+    diagnostics:    *diagnostics || *extendedDiagnostics,
+    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)
@@ -232,21 +275,13 @@ 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, diagnosticsTiming, err := collectDiagnosticsTimed(prog, engine)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
-  if !externalRan {
-    warnUnknownRules(os.Stderr, engine.UnknownRules())
-  }
+  printLintDiagnosticsTiming(os.Stdout, opts.diagnostics, diagnosticsTiming)
+  warnUnknownRules(os.Stderr, engine.UnknownRules())
   if errCount := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, opts.cwd); errCount > 0 {
     return 2
   }
@@ -298,8 +333,9 @@ func loadRules(pluginsJSON, cwd, tsconfigPath string) (RuleResolver, error) {
 }
 
 // warnUnknownRules writes one warning line per name in `unknown` to `w`.
-// Called after engine construction when no external ESLint process handled
-// the run (the external runner surfaces its own unknown-rule warnings).
+// 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)
@@ -344,10 +380,22 @@ 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, lintDiags, _, err := collectDiagnosticsTimed(prog, engine)
+  return astDiags, lintDiags, err
+}
+
+type lintDiagnosticsTiming struct {
+  lint time.Duration
+}
+
+func collectDiagnosticsTimed(prog *program, engine *Engine) ([]*shimast.Diagnostic, []*shimdw.LintDiagnostic, lintDiagnosticsTiming, error) {
+  timing := lintDiagnosticsTiming{}
   astDiags := prog.programDiagnostics()
   files := prog.userSourceFiles()
+  lintStarted := time.Now()
   findings := engine.Run(files, prog.checker)
+  timing.lint = time.Since(lintStarted)
   nativeDiags := make([]*shimdw.LintDiagnostic, 0, len(findings))
   for _, finding := range findings {
     category := shimdw.LintCategoryError
@@ -363,68 +411,18 @@ 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
+  return astDiags, nativeDiags, timing, nil
 }
 
-// mergeNativeAndExternalDiagnostics combines native lint findings with
-// external ESLint diagnostics. Any native diagnostic whose rule name also
-// appears in the external set is dropped to avoid duplicate reporting —
-// the external runner's output is authoritative for rules it covered.
-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)
+func printLintDiagnosticsTiming(w io.Writer, enabled bool, timing lintDiagnosticsTiming) {
+  if !enabled {
+    return
   }
-  return append(out, externalDiags...)
-}
-
-// lintDiagnosticRule extracts the rule name from the `[rule-name]` prefix
-// that `collectDiagnostics` injects into every lint diagnostic message.
-// Returns "" when the message does not follow the expected format.
-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]
+  fmt.Fprintf(w, "@ttsc/lint time: %s\n", formatTimingSeconds(timing.lint))
 }
 
-// canonicalLintRule trims ESLint namespace prefixes from `rule` so that
-// `no-var`, `@typescript-eslint/no-var`, and `typescript-eslint/no-var`
-// all compare equal during deduplication.
-func canonicalLintRule(rule string) string {
-  rule = strings.TrimSpace(rule)
-  rule = strings.TrimPrefix(rule, "@typescript-eslint/")
-  rule = strings.TrimPrefix(rule, "typescript-eslint/")
-  return rule
+func formatTimingSeconds(duration time.Duration) string {
+  return fmt.Sprintf("%.3fs", duration.Seconds())
 }
 
 // RuleCode hashes a rule name into a stable, positive int32 so the