@ttsc/lint 0.18.4 → 0.19.1

package/linthost/host.go

@@ -13,8 +13,10 @@ import (
   "context"
   "errors"
   "fmt"
+  "os"
   "path/filepath"
   "strings"
+  "sync/atomic"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   "github.com/microsoft/typescript-go/shim/bundled"
@@ -25,24 +27,29 @@ import (
   shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   "github.com/microsoft/typescript-go/shim/vfs/cachedvfs"
   "github.com/microsoft/typescript-go/shim/vfs/osvfs"
+
+  publicrule "github.com/samchon/ttsc/packages/lint/rule"
 )
 
-// program bundles the tsgo Program with the parsed config and a checker
-// release callback so the orchestration code can clean up after itself.
+var programLifecycleSequence atomic.Uint64
+
+// program bundles the tsgo Program with the parsed config and the standalone
+// checker used only by type-aware lint rules.
 type program struct {
-  cwd            string
-  tsProgram      *shimcompiler.Program
-  parsed         *tsoptions.ParsedCommandLine
-  checker        *shimchecker.Checker
-  releaseChecker func()
+  cwd          string
+  tsProgram    *shimcompiler.Program
+  parsed       *tsoptions.ParsedCommandLine
+  checker      *shimchecker.Checker
+  identity     publicrule.ProjectIdentity
+  projectCycle *projectCycle
 }
 
 type loadProgramOptions struct {
   forceEmit   bool
   forceNoEmit bool
   outDir      string
-  // needsRuleChecker asks loadProgram to pin the checker pool and acquire the
-  // checker that type-aware lint rules receive through Context.Checker.
+  // needsRuleChecker asks loadProgram to create the standalone checker that
+  // type-aware lint rules receive through Context.Checker.
   needsRuleChecker bool
   // singleThreaded mirrors `tsgo --singleThreaded`: one checker, serial
   // parse/check/emit.
@@ -54,11 +61,12 @@ type loadProgramOptions struct {
   // `--target es2020`, …). They are parsed through TypeScript-Go's own
   // command-line parser into a CompilerOptions overlay that wins over the
   // tsconfig, exactly as tsgo's CLI merges them.
-  tsgoArgs []string
+  tsgoArgs        []string
+  projectIdentity publicrule.ProjectIdentity
 }
 
 // loadProgram parses the given tsconfig and builds a Program. When
-// needsRuleChecker is set, it also acquires a type checker for lint rules.
+// needsRuleChecker is set, it also creates a standalone checker for lint rules.
 // Mirrors the canonical bootstrap pattern from
 // `03-tsgo.md` — the only ttsc-specific bit is that `forceEmit`/
 // `forceNoEmit`/`outDir` overrides are merged into the parsed config
@@ -111,20 +119,15 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
     overrideOutDir(cwd, parsed, options.outDir)
   }
   applyThreading(parsed, options.singleThreaded, options.checkers)
-  if options.needsRuleChecker {
-    forceSingleChecker(parsed)
-  }
 
-  // SingleThreaded is left unset so the program keeps TypeScript-Go's parallel
-  // source parsing and parallel emit. For type-aware lint rules, the checker
-  // pool is pinned to a single checker (see forceSingleChecker): the lint
-  // engine walks files serially against the one checker GetTypeChecker hands
-  // back, and rules ask that checker to resolve types in nodes drawn from every
-  // source file. TypeScript-Go's multi-checker pool affinitizes each file to a
-  // different checker and forbids mixing types across them, so a type whose
-  // declarations span files on different checkers (e.g. a circular
-  // indexed-access alias) resolves to `any` on the borrowed checker. AST-only
-  // lint rules do not receive a checker, so they keep the user's checker pool.
+  // Keep the user's checker pool intact for parallel semantic diagnostics.
+  // Type-aware lint rules cannot borrow one member of that pool: they walk
+  // every source file through a single Context.Checker, while TypeScript-Go
+  // affinitizes files to different pool members and forbids mixing their type
+  // graphs. Instead, lint owns a standalone checker over the same Program.
+  // Every lint type is then produced by one checker, while the Program's pool
+  // remains free to check its file groups in parallel. The engine serializes
+  // type-aware walks, so this dedicated checker is never accessed concurrently.
   tsProgram := shimcompiler.NewProgram(shimcompiler.ProgramOptions{
     Config:                      parsed,
     Host:                        host,
@@ -134,29 +137,145 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
     return nil, nil, errors.New("compiler.NewProgram returned nil")
   }
   var checker *shimchecker.Checker
-  var release func()
   if options.needsRuleChecker {
-    checker, release = tsProgram.GetTypeChecker(context.Background())
+    checker, _ = shimchecker.NewChecker(tsProgram, nil)
   }
   return &program{
-    cwd:            cwd,
-    tsProgram:      tsProgram,
-    parsed:         parsed,
-    checker:        checker,
-    releaseChecker: release,
+    cwd:       cwd,
+    tsProgram: tsProgram,
+    parsed:    parsed,
+    checker:   checker,
+    identity:  normalizeProjectIdentity(options.projectIdentity, cwd, resolved),
   }, nil, nil
 }
 
-// close releases the type checker acquired by loadProgram. Safe to call on
-// a nil receiver and idempotent after the first call.
+func normalizeProjectIdentity(
+  identity publicrule.ProjectIdentity,
+  cwd string,
+  configPath string,
+) publicrule.ProjectIdentity {
+  if identity.InvocationCwd == "" {
+    identity.InvocationCwd = cwd
+  }
+  if identity.LogicalConfigPath == "" {
+    identity.LogicalConfigPath = absoluteProjectPath(identity.InvocationCwd, configPath)
+  }
+  if identity.LogicalProjectRoot == "" {
+    identity.LogicalProjectRoot = filepath.Dir(identity.LogicalConfigPath)
+  }
+  if identity.PhysicalConfigPath == "" {
+    identity.PhysicalConfigPath = realProjectPath(absoluteProjectPath(cwd, configPath))
+  }
+  if identity.PhysicalProjectRoot == "" {
+    identity.PhysicalProjectRoot = realProjectPath(cwd)
+  }
+  if identity.PluginConfigOrigin == "" {
+    if origin := os.Getenv("TTSC_PLUGIN_CONFIG_DIR"); origin != "" {
+      identity.PluginConfigOrigin = absoluteProjectPath(identity.InvocationCwd, origin)
+    }
+  }
+  identity.LifecycleID = fmt.Sprintf(
+    "%d:%d",
+    os.Getpid(),
+    programLifecycleSequence.Add(1),
+  )
+  return identity
+}
+
+func absoluteProjectPath(cwd string, target string) string {
+  if filepath.IsAbs(target) {
+    return filepath.Clean(target)
+  }
+  return filepath.Clean(filepath.Join(cwd, target))
+}
+
+func realProjectPath(target string) string {
+  original := filepath.Clean(target)
+  resolved := original
+  seen := make(map[string]struct{})
+  for range 255 {
+    key := filepath.Clean(resolved)
+    if _, exists := seen[key]; exists {
+      return original
+    }
+    seen[key] = struct{}{}
+
+    next, ok := resolveProjectPathAncestor(resolved)
+    if !ok {
+      return filepath.Clean(resolved)
+    }
+    resolved = next
+  }
+  return original
+}
+
+// resolveProjectPathAncestor resolves the nearest existing or symlink-like
+// ancestor and reattaches the remaining path. Besides ordinary links, this
+// lets Windows expand an 8.3 short-name ancestor even when the target itself
+// has not been created yet. Some directory junctions are readable through
+// os.Readlink while EvalSymlinks either leaves them unchanged or fails on their
+// children, so both resolution paths are retained.
+func resolveProjectPathAncestor(target string) (string, bool) {
+  original := filepath.Clean(target)
+  probe := original
+  suffix := make([]string, 0)
+  evaluateAncestor := true
+  for {
+    if evaluateAncestor {
+      if evaluated, err := filepath.EvalSymlinks(probe); err == nil {
+        // EvalSymlinks resolves the probe's complete ancestry. If it leaves
+        // the spelling unchanged, retrying it on every parent cannot reveal
+        // anything new; retain only the os.Readlink walk for junctions that
+        // EvalSymlinks does not expose.
+        evaluateAncestor = false
+        candidate := filepath.Clean(evaluated)
+        for i := len(suffix) - 1; i >= 0; i-- {
+          candidate = filepath.Join(candidate, suffix[i])
+        }
+        candidate = filepath.Clean(candidate)
+        if candidate != original {
+          return candidate, true
+        }
+      }
+    }
+    if _, err := os.Readlink(probe); err == nil {
+      destination := resolveDirLink(probe)
+      for i := len(suffix) - 1; i >= 0; i-- {
+        destination = filepath.Join(destination, suffix[i])
+      }
+      destination = filepath.Clean(destination)
+      if destination != original {
+        return destination, true
+      }
+    }
+    parent := filepath.Dir(probe)
+    if parent == probe {
+      return "", false
+    }
+    suffix = append(suffix, filepath.Base(probe))
+    probe = parent
+  }
+}
+
+func (p *program) runLintCycle(engine *Engine) []*Finding {
+  if p == nil || engine == nil {
+    return nil
+  }
+  files := p.userSourceFiles()
+  if p.projectCycle == nil {
+    p.projectCycle = engine.evaluateProject(p.identity, files, p.checker)
+  }
+  fileFindings := engine.runFiles(files, p.checker, p.projectCycle.results, p.cwd)
+  return append(p.projectCycle.finalize(), fileFindings...)
+}
+
+// close drops the standalone lint checker. Safe to call on a nil receiver and
+// idempotent after the first call.
 func (p *program) close() {
   if p == nil {
     return
   }
-  if p.releaseChecker != nil {
-    p.releaseChecker()
-    p.releaseChecker = nil
-  }
+  p.checker = nil
 }
 
 // userSourceFiles returns the tsconfig-selected source files the lint engine
@@ -290,10 +409,9 @@ func parseTsgoArgs(args []string, host shimcompiler.CompilerHost) (*shimcore.Com
 // CompilerOptions, and both Program.SingleThreaded() and the checker pool read
 // them from there. SingleThreaded wins over Checkers, matching the pool.
 //
-// When a type-aware lint rule is active, loadProgram calls forceSingleChecker
-// afterwards, so a `--checkers N` greater than 1 is recorded here and then
-// clamped back to a single checker. AST-only lint runs keep the recorded
-// checker count. `--singleThreaded` still takes full effect.
+// Type-aware lint rules use their own standalone checker, so this pool size is
+// preserved for the Program's semantic diagnostics. `--singleThreaded` still
+// takes full effect across the Program and the serial type-aware lint walk.
 func applyThreading(parsed *tsoptions.ParsedCommandLine, singleThreaded bool, checkers int) {
   if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
     return
@@ -308,26 +426,6 @@ func applyThreading(parsed *tsoptions.ParsedCommandLine, singleThreaded bool, ch
   }
 }
 
-// forceSingleChecker pins the TypeScript-Go checker pool to a single checker.
-//
-// The lint engine walks the program serially and obtains types through the
-// single checker GetTypeChecker hands back. Rules query types on nodes from
-// arbitrary source files, so the checker must be the same one that checked
-// every file. A pool of size > 1 affinitizes files to distinct checkers;
-// resolving a type whose declarations cross that boundary yields `any`.
-// Parallel parsing and emit are unaffected — they do not consult the count.
-func forceSingleChecker(parsed *tsoptions.ParsedCommandLine) {
-  if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
-    return
-  }
-  options := parsed.ParsedConfig.CompilerOptions
-  if options.SingleThreaded == shimcore.TSTrue {
-    return
-  }
-  one := 1
-  options.Checkers = &one
-}
-
 // overrideOutDir replaces the parsed config's OutDir with `outDir`.
 // Relative outDir values are resolved against `cwd`; absolute paths are
 // used as-is. Paths are converted to forward slashes for tsgo

package/linthost/literal_escape_scan.go

@@ -0,0 +1,117 @@
+// Raw-source scanning for the numeric escape sequences (`\xHH`, `\uHHHH`,
+// `\u{HEX...}`) that `unicorn/no-hex-escape` and `unicorn/escape-case`
+// police. Both rules read the raw literal source — the parser already
+// decodes escapes into the `.Text` value, so a normal accessor would see
+// `©` instead of `\xA9` — and both therefore need the same two guards a
+// regex port cannot express in RE2:
+//
+//   - Backslash parity: only a backslash preceded by an even-length
+//     backslash run opens an escape. Upstream spells this as the
+//     lookbehind `(?<=(?:^|[^\\])(?:\\\\)*\\)` and, in its byte-scanning
+//     rules, as `isActiveBackslash`. Without it, the second backslash of
+//     an escaped `\\` donates itself to a bogus match and `"\\x64"` (a
+//     backslash followed by the literal text `x64`) reports.
+//   - Fixed-width digit runs: `\x` takes exactly two hex digits and `\u`
+//     exactly four, so an escape never absorbs the literal hex-looking
+//     characters that follow it (`"\x41bcd"` is a canonical `\x41` plus
+//     the letters `bcd`). Only the braced `\u{HEX...}` form is variable
+//     width, and its `}` terminates it.
+//
+// Byte scanning is UTF-8 safe: every byte the scanner tests is ASCII, and
+// a multi-byte sequence contains no ASCII bytes.
+package linthost
+
+// literalEscape is one numeric escape sequence found in raw literal source.
+// `Prefix` is the character introducing it (`x` for `\xHH`, `u` for both
+// `\uHHHH` and `\u{HEX...}`) and `Digits` is its hex payload with the `\u{`
+// / `}` brackets stripped.
+type literalEscape struct {
+  Prefix byte
+  Digits string
+}
+
+// hasActiveLiteralEscape reports whether `text` contains an escape sequence
+// accepted by `match` whose backslash is active — preceded by an even-length
+// run of backslashes.
+//
+// `text` is the raw source of one string literal or template element token,
+// delimiters included. Including them changes nothing: a quote, backtick,
+// `}`, or `${` is never a backslash, so the parity of every run inside the
+// payload is the same as it would be for the delimiter-free raw value
+// upstream reads off `TemplateElement.value.raw`.
+func hasActiveLiteralEscape(text string, match func(escape literalEscape) bool) bool {
+  for index := 0; index < len(text); {
+    if text[index] != '\\' {
+      index++
+      continue
+    }
+    run := 0
+    for index < len(text) && text[index] == '\\' {
+      run++
+      index++
+    }
+    // An even-length run is a sequence of escaped backslashes: each one
+    // consumes the next, none is left over to open an escape, and the text
+    // behind the run is literal. Only the last backslash of an odd-length
+    // run is active, and it opens the escape at `index`.
+    if run%2 == 0 {
+      continue
+    }
+    if escape, ok := literalEscapeAt(text[index:]); ok && match(escape) {
+      return true
+    }
+    // `text[index]` is the escaped character, never a backslash (the run
+    // above consumed every one), so the outer loop may step over it.
+  }
+  return false
+}
+
+// literalEscapeAt parses the escape sequence opened at `text[0]`, the byte
+// right after an active backslash. It recognizes exactly the three numeric
+// forms of upstream's `x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|u{[\dA-Fa-f]+}`
+// alternation; any other escape (`\n`, `\\`, `\$`, a line continuation, an
+// identifier escape) is not a numeric escape and fails the parse.
+func literalEscapeAt(text string) (literalEscape, bool) {
+  if text == "" {
+    return literalEscape{}, false
+  }
+  switch text[0] {
+  case 'x':
+    if digits, ok := literalEscapeDigits(text[1:], 2); ok {
+      return literalEscape{Prefix: 'x', Digits: digits}, true
+    }
+  case 'u':
+    // The braced form is the only variable-width escape. `{` is not a hex
+    // digit, so the fixed-width `\uHHHH` form can never match here and the
+    // brace branch owns the decision.
+    if len(text) > 1 && text[1] == '{' {
+      end := 2
+      for end < len(text) && hexDigit(text[end]) >= 0 {
+        end++
+      }
+      if end == 2 || end >= len(text) || text[end] != '}' {
+        return literalEscape{}, false
+      }
+      return literalEscape{Prefix: 'u', Digits: text[2:end]}, true
+    }
+    if digits, ok := literalEscapeDigits(text[1:], 4); ok {
+      return literalEscape{Prefix: 'u', Digits: digits}, true
+    }
+  }
+  return literalEscape{}, false
+}
+
+// literalEscapeDigits returns the first `count` bytes of `text` when every
+// one of them is a hex digit — the fixed-width digit run of a `\xHH` or
+// `\uHHHH` escape.
+func literalEscapeDigits(text string, count int) (string, bool) {
+  if len(text) < count {
+    return "", false
+  }
+  for index := 0; index < count; index++ {
+    if hexDigit(text[index]) < 0 {
+      return "", false
+    }
+  }
+  return text[:count], true
+}