@ttsc/lint 0.18.4 → 0.19.1

package/linthost/comment_scan.go

@@ -0,0 +1,154 @@
+// Shared parser-aware comment enumeration for every rule or pass that needs
+// exact comment byte ranges (inline directives, ban-ts-comment, and switch
+// default markers).
+package linthost
+
+import (
+  "sort"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+type commentToken struct {
+  kind shimast.Kind
+  pos  int
+  end  int
+}
+
+type sourceSpan struct {
+  pos int
+  end int
+}
+
+// forEachCommentToken visits every real comment in `file` in source order.
+//
+// TypeScript's parser, rather than a context-free scanner, owns the lexical
+// goal for regular expressions, templates, and JSX. The parsed AST retains
+// those context-sensitive tokens as exact spans. We treat those spans as
+// opaque and scan only the gaps between them, where slash-shaped bytes are
+// ordinary JavaScript trivia or punctuation. This preserves the scanner's
+// complete comment and line-terminator behavior without guessing whether a
+// slash is division, manually tracking template braces, or special-casing JSX
+// strings. Exact ranges are deduplicated before the callback runs because a
+// recovery AST can expose overlapping token nodes for malformed source.
+func forEachCommentToken(file *shimast.SourceFile, visit func(kind shimast.Kind, pos, end int)) {
+  if file == nil || visit == nil {
+    return
+  }
+  text := file.Text()
+  opaque := parserOpaqueTokenSpans(file)
+  comments := make([]commentToken, 0)
+  seen := make(map[sourceSpan]struct{})
+  gapScanner := shimscanner.NewScanner()
+  collect := func(kind shimast.Kind, pos, end int) {
+    if pos < 0 || end <= pos || end > len(text) {
+      return
+    }
+    span := sourceSpan{pos: pos, end: end}
+    if _, ok := seen[span]; ok {
+      return
+    }
+    seen[span] = struct{}{}
+    comments = append(comments, commentToken{kind: kind, pos: pos, end: end})
+  }
+
+  cursor := 0
+  for _, span := range opaque {
+    if cursor < span.pos {
+      scanCommentGap(gapScanner, text, cursor, span.pos, collect)
+    }
+    if span.end > cursor {
+      cursor = span.end
+    }
+  }
+  if cursor < len(text) {
+    scanCommentGap(gapScanner, text, cursor, len(text), collect)
+  }
+
+  sort.Slice(comments, func(i, j int) bool {
+    if comments[i].pos != comments[j].pos {
+      return comments[i].pos < comments[j].pos
+    }
+    return comments[i].end < comments[j].end
+  })
+  for _, comment := range comments {
+    visit(comment.kind, comment.pos, comment.end)
+  }
+}
+
+// parserOpaqueTokenSpans returns merged source ranges for the parser-owned
+// tokens whose contents a context-free scanner cannot classify: strings,
+// regex literals, template heads/middles/tails, and JSX text. Numeric literals,
+// identifiers, keywords, and punctuation remain in the scanned gaps because
+// they cannot contain comment-shaped source bytes; keeping them there avoids a
+// scanner reset for every ordinary token.
+func parserOpaqueTokenSpans(file *shimast.SourceFile) []sourceSpan {
+  spans := make([]sourceSpan, 0)
+  var walk func(*shimast.Node)
+  walk = func(node *shimast.Node) {
+    if node == nil {
+      return
+    }
+    if parserOpaqueTokenKind(node.Kind) {
+      pos := shimscanner.GetTokenPosOfNode(node, file, false /*includeJSDoc*/)
+      if pos >= 0 && node.End() > pos && node.End() <= len(file.Text()) {
+        spans = append(spans, sourceSpan{pos: pos, end: node.End()})
+      }
+      return
+    }
+    node.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(file.AsNode())
+  sort.Slice(spans, func(i, j int) bool {
+    if spans[i].pos != spans[j].pos {
+      return spans[i].pos < spans[j].pos
+    }
+    return spans[i].end < spans[j].end
+  })
+  if len(spans) < 2 {
+    return spans
+  }
+  merged := spans[:1]
+  for _, span := range spans[1:] {
+    last := &merged[len(merged)-1]
+    if span.pos <= last.end {
+      if span.end > last.end {
+        last.end = span.end
+      }
+      continue
+    }
+    merged = append(merged, span)
+  }
+  return merged
+}
+
+func parserOpaqueTokenKind(kind shimast.Kind) bool {
+  return kind >= shimast.KindStringLiteral && kind <= shimast.KindLastLiteralToken ||
+    kind >= shimast.KindFirstTemplateToken && kind <= shimast.KindLastTemplateToken
+}
+
+// scanCommentGap scans one parser-classified non-token gap. Context-sensitive
+// token bodies never enter this function, so every comment trivia token it
+// returns is a real source comment. Scanning the isolated gap also preserves
+// CRLF and Unicode line-terminator behavior without range arithmetic in a
+// second comment parser.
+func scanCommentGap(scanner *shimscanner.Scanner, text string, from, to int, visit func(kind shimast.Kind, pos, end int)) {
+  if scanner == nil || from < 0 || to <= from || to > len(text) {
+    return
+  }
+  scanner.SetText(text[from:to])
+  scanner.SetSkipTrivia(false)
+  for {
+    kind := scanner.Scan()
+    switch kind {
+    case shimast.KindEndOfFile:
+      return
+    case shimast.KindSingleLineCommentTrivia, shimast.KindMultiLineCommentTrivia:
+      visit(kind, from+scanner.TokenStart(), from+scanner.TokenEnd())
+    }
+  }
+}

package/linthost/compile.go

@@ -27,13 +27,20 @@ import (
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimdw "github.com/microsoft/typescript-go/shim/diagnosticwriter"
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
 )
 
 // RunCheck implements `@ttsc/lint check` — typecheck + lint, no emit.
 func RunCheck(args []string) int {
-  opts, err := parseSubcommandFlags("check", args)
+  return RunCheckWithIO(args, os.Stdout, os.Stderr)
+}
+
+// RunCheckWithIO runs check with invocation-owned output streams.
+func RunCheckWithIO(args []string, stdout, stderr io.Writer) int {
+  opts, err := parseSubcommandFlagsWithIO("check", args, stdout, stderr)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(stderr, err)
     return 2
   }
   opts.noEmit = true
@@ -43,9 +50,14 @@ func RunCheck(args []string) int {
 // RunBuild implements `@ttsc/lint build` — same diagnostic flow as
 // `check`, plus the tsgo emit pipeline when emit is requested.
 func RunBuild(args []string) int {
-  opts, err := parseSubcommandFlags("build", args)
+  return RunBuildWithIO(args, os.Stdout, os.Stderr)
+}
+
+// RunBuildWithIO runs build with invocation-owned output streams.
+func RunBuildWithIO(args []string, stdout, stderr io.Writer) int {
+  opts, err := parseSubcommandFlagsWithIO("build", args, stdout, stderr)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(stderr, err)
     return 2
   }
   return runProject(opts)
@@ -55,13 +67,19 @@ func RunBuild(args []string) int {
 // still run for the whole program (lint quality depends on context), but
 // emit is restricted to the requested file's JS output.
 func RunTransform(args []string) int {
+  return RunTransformWithIO(args, os.Stdout, os.Stderr)
+}
+
+// RunTransformWithIO runs transform with invocation-owned output streams.
+func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
   fs := flag.NewFlagSet("transform", flag.ContinueOnError)
-  fs.SetOutput(os.Stderr)
+  fs.SetOutput(stderr)
   file := fs.String("file", "", "absolute or cwd-relative path of the .ts file to transform")
   out := fs.String("out", "", "write output JS to PATH (default: stdout)")
   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")
+  projectContextJSON := fs.String("project-context-json", "", "ttsc project identity JSON")
   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")
@@ -71,25 +89,34 @@ func RunTransform(args []string) int {
     return 2
   }
   if *file == "" {
-    fmt.Fprintln(os.Stderr, "@ttsc/lint transform: --file is required")
+    fmt.Fprintln(stderr, "@ttsc/lint transform: --file is required")
     return 2
   }
   tsgoArgs, err := decodeTsgoArgs(*tsgoArgsRaw)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(stderr, err)
     return 2
   }
   resolvedCwd, err := resolveCwd(*cwd)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(stderr, err)
+    return 2
+  }
+  projectIdentity, err := decodeProjectIdentity(*projectContextJSON)
+  if err != nil {
+    fmt.Fprintln(stderr, err)
     return 2
   }
   rules, err := loadRules(*pluginsJSON, resolvedCwd, *tsconfig)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(stderr, err)
     return 2
   }
   engine := NewEngineWithResolver(rules)
+  if err := engine.ConfigError(); err != nil {
+    fmt.Fprintln(stderr, err)
+    return 2
+  }
   engine.SetSerial(*singleThreaded)
 
   prog, parseDiags, err := loadProgram(resolvedCwd, *tsconfig, loadProgramOptions{
@@ -98,24 +125,25 @@ func RunTransform(args []string) int {
     singleThreaded:   *singleThreaded,
     checkers:         *checkers,
     tsgoArgs:         tsgoArgs,
+    projectIdentity:  projectIdentity,
   })
   if err != nil {
-    fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
+    fmt.Fprintf(stderr, "@ttsc/lint: %v\n", err)
     return 2
   }
   if len(parseDiags) > 0 {
-    shimdw.FormatASTDiagnosticsWithColorAndContext(os.Stderr, parseDiags, resolvedCwd)
+    shimdw.FormatASTDiagnosticsWithColorAndContext(stderr, parseDiags, resolvedCwd)
     return 2
   }
   defer prog.close()
 
   astDiags, lintDiags, err := collectDiagnostics(prog, engine)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(stderr, err)
     return 2
   }
-  warnUnknownRules(os.Stderr, engine.UnknownRules())
-  if errors := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, resolvedCwd); errors > 0 {
+  warnUnknownRules(stderr, engine.UnknownRules())
+  if errors := shimdw.FormatMixedDiagnostics(stderr, astDiags, lintDiags, resolvedCwd); errors > 0 {
     return 2
   }
 
@@ -128,7 +156,7 @@ func RunTransform(args []string) int {
   absFile := shimtspath.ResolvePath(resolvedCwd, *file)
   target := prog.findSourceFile(absFile)
   if target == nil {
-    fmt.Fprintf(os.Stderr, "@ttsc/lint transform: source file not in program: %s\n", absFile)
+    fmt.Fprintf(stderr, "@ttsc/lint transform: source file not in program: %s\n", absFile)
     return 2
   }
 
@@ -145,55 +173,69 @@ func RunTransform(args []string) int {
     WriteFile:        shimcompiler.WriteFile(capture),
   })
   if result == nil {
-    fmt.Fprintln(os.Stderr, "@ttsc/lint transform: Emit returned nil")
+    fmt.Fprintln(stderr, "@ttsc/lint transform: Emit returned nil")
     return 3
   }
   if len(result.Diagnostics) > 0 {
-    shimdw.FormatASTDiagnosticsWithColorAndContext(os.Stderr, result.Diagnostics, resolvedCwd)
+    shimdw.FormatASTDiagnosticsWithColorAndContext(stderr, result.Diagnostics, resolvedCwd)
   }
   if captured == "" {
-    fmt.Fprintf(os.Stderr, "@ttsc/lint transform: no output produced for %s\n", absFile)
+    fmt.Fprintf(stderr, "@ttsc/lint transform: no output produced for %s\n", absFile)
     return 3
   }
   if *out == "" {
-    fmt.Fprint(os.Stdout, captured)
+    fmt.Fprint(stdout, captured)
     return 0
   }
   if err := os.MkdirAll(filepath.Dir(*out), 0o755); err != nil {
-    fmt.Fprintf(os.Stderr, "@ttsc/lint transform: mkdir: %v\n", err)
+    fmt.Fprintf(stderr, "@ttsc/lint transform: mkdir: %v\n", err)
     return 3
   }
   if err := os.WriteFile(*out, []byte(captured), 0o644); err != nil {
-    fmt.Fprintf(os.Stderr, "@ttsc/lint transform: write: %v\n", err)
+    fmt.Fprintf(stderr, "@ttsc/lint transform: write: %v\n", err)
     return 3
   }
   return 0
 }
 
 type subcommandOpts struct {
-  cwd            string
-  tsconfig       string
-  pluginsJSON    string
-  emit           bool
-  noEmit         bool
-  quiet          bool
-  verbose        bool
-  diagnostics    bool
-  outDir         string
-  singleThreaded bool
-  checkers       int
-  tsgoArgs       []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
+  projectIdentity publicrule.ProjectIdentity
+  stdout          io.Writer
+  stderr          io.Writer
 }
 
 // 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) {
+  return parseSubcommandFlagsWithIO(name, args, os.Stdout, os.Stderr)
+}
+
+func parseSubcommandFlagsWithIO(name string, args []string, stdout, stderr io.Writer) (*subcommandOpts, error) {
+  if stdout == nil {
+    stdout = io.Discard
+  }
+  if stderr == nil {
+    stderr = io.Discard
+  }
   fs := flag.NewFlagSet(name, flag.ContinueOnError)
-  fs.SetOutput(os.Stderr)
+  fs.SetOutput(stderr)
   cwd := fs.String("cwd", "", "")
   tsconfig := fs.String("tsconfig", "tsconfig.json", "")
   pluginsJSON := fs.String("plugins-json", "", "")
+  projectContextJSON := fs.String("project-context-json", "", "")
   emit := fs.Bool("emit", false, "")
   noEmit := fs.Bool("noEmit", false, "")
   quiet := fs.Bool("quiet", false, "")
@@ -218,19 +260,26 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
   if err != nil {
     return nil, err
   }
+  projectIdentity, err := decodeProjectIdentity(*projectContextJSON)
+  if err != nil {
+    return nil, err
+  }
   return &subcommandOpts{
-    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,
+    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,
+    projectIdentity: projectIdentity,
+    stdout:          stdout,
+    stderr:          stderr,
   }, nil
 }
 
@@ -254,10 +303,14 @@ func decodeTsgoArgs(raw string) ([]string, error) {
 func runProject(opts *subcommandOpts) int {
   rules, err := loadRules(opts.pluginsJSON, opts.cwd, opts.tsconfig)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(opts.stderr, err)
     return 2
   }
   engine := NewEngineWithResolver(rules)
+  if err := engine.ConfigError(); err != nil {
+    fmt.Fprintln(opts.stderr, err)
+    return 2
+  }
   engine.SetSerial(opts.singleThreaded)
 
   prog, parseDiags, err := loadProgram(opts.cwd, opts.tsconfig, loadProgramOptions{
@@ -268,25 +321,26 @@ func runProject(opts *subcommandOpts) int {
     singleThreaded:   opts.singleThreaded,
     checkers:         opts.checkers,
     tsgoArgs:         opts.tsgoArgs,
+    projectIdentity:  opts.projectIdentity,
   })
   if err != nil {
-    fmt.Fprintf(os.Stderr, "@ttsc/lint: %v\n", err)
+    fmt.Fprintf(opts.stderr, "@ttsc/lint: %v\n", err)
     return 2
   }
   if len(parseDiags) > 0 {
-    shimdw.FormatASTDiagnosticsWithColorAndContext(os.Stderr, parseDiags, opts.cwd)
+    shimdw.FormatASTDiagnosticsWithColorAndContext(opts.stderr, parseDiags, opts.cwd)
     return 2
   }
   defer prog.close()
 
   astDiags, lintDiags, diagnosticsTiming, err := collectDiagnosticsTimed(prog, engine)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(opts.stderr, err)
     return 2
   }
-  printLintDiagnosticsTiming(os.Stdout, opts.diagnostics, diagnosticsTiming)
-  warnUnknownRules(os.Stderr, engine.UnknownRules())
-  if errCount := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, opts.cwd); errCount > 0 {
+  printLintDiagnosticsTiming(opts.stdout, opts.diagnostics, diagnosticsTiming)
+  warnUnknownRules(opts.stderr, engine.UnknownRules())
+  if errCount := shimdw.FormatMixedDiagnostics(opts.stderr, astDiags, lintDiags, opts.cwd); errCount > 0 {
     return 2
   }
 
@@ -300,19 +354,19 @@ func runProject(opts *subcommandOpts) int {
     }),
   })
   if result == nil {
-    fmt.Fprintln(os.Stderr, "@ttsc/lint: Emit returned nil")
+    fmt.Fprintln(opts.stderr, "@ttsc/lint: Emit returned nil")
     return 3
   }
   if len(result.Diagnostics) > 0 {
-    errCount := shimdw.FormatMixedDiagnostics(os.Stderr, result.Diagnostics, nil, opts.cwd)
+    errCount := shimdw.FormatMixedDiagnostics(opts.stderr, result.Diagnostics, nil, opts.cwd)
     if errCount > 0 {
       return 2
     }
   }
   if opts.verbose && result.EmittedFiles != nil {
-    fmt.Fprintf(os.Stdout, "@ttsc/lint: emitted=%d files\n", len(result.EmittedFiles))
+    fmt.Fprintf(opts.stdout, "@ttsc/lint: emitted=%d files\n", len(result.EmittedFiles))
     for _, f := range result.EmittedFiles {
-      fmt.Fprintln(os.Stdout, "  +", f)
+      fmt.Fprintln(opts.stdout, "  +", f)
     }
   }
   return 0
@@ -331,9 +385,24 @@ func loadRules(pluginsJSON, cwd, tsconfigPath string) (RuleResolver, error) {
     return nil, err
   }
   if entry == nil {
-    return RuleConfig{}, nil
+    return bindProjectRuleResolver(RuleConfig{})
+  }
+  resolver, err := LoadConfigResolver(entry, cwd, tsconfigPath)
+  if err != nil {
+    return nil, err
   }
-  return LoadConfigResolver(entry, cwd, tsconfigPath)
+  return bindProjectRuleResolver(resolver)
+}
+
+func decodeProjectIdentity(raw string) (publicrule.ProjectIdentity, error) {
+  if strings.TrimSpace(raw) == "" {
+    return publicrule.ProjectIdentity{}, nil
+  }
+  var identity publicrule.ProjectIdentity
+  if err := json.Unmarshal([]byte(raw), &identity); err != nil {
+    return publicrule.ProjectIdentity{}, fmt.Errorf("@ttsc/lint: invalid --project-context-json: %w", err)
+  }
+  return identity, nil
 }
 
 // warnUnknownRules writes one warning line per name in `unknown` to `w`.
@@ -396,9 +465,8 @@ type lintDiagnosticsTiming struct {
 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)
+  findings := prog.runLintCycle(engine)
   timing.lint = time.Since(lintStarted)
   nativeDiags := make([]*shimdw.LintDiagnostic, 0, len(findings))
   for _, finding := range findings {
@@ -429,24 +497,6 @@ func formatTimingSeconds(duration time.Duration) string {
   return fmt.Sprintf("%.3fs", duration.Seconds())
 }
 
-// RuleCode hashes a rule name into a stable, positive int32 so the
-// renderer's banner (`TS9123`-style) is unique per rule. Codes start at
-// 9000 to avoid colliding with tsgo's diagnostic codes (which top out
-// well below that range). Public because tests pin the hash band.
-func RuleCode(name string) int32 {
-  const prime = 16777619
-  var h uint32 = 2166136261
-  for i := 0; i < len(name); i++ {
-    h ^= uint32(name[i])
-    h *= prime
-  }
-  return int32(9000 + (h % 9000))
-}
-
-// ruleCode is the internal alias kept for callers in the same package
-// 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.