@ttsc/lint 0.33.1 → 0.34.1

package/linthost/host.go

@@ -48,9 +48,12 @@ type program struct {
   configInputs  []configDependencyFingerprint
   tsProgram     *shimcompiler.Program
   parsed        *tsoptions.ParsedCommandLine
-  checker       *shimchecker.Checker
-  identity      publicrule.ProjectIdentity
-  projectCycle  *projectCycle
+  // hosts builds every generation's compiler host and owns the content-mapper
+  // processes those hosts share on the TypeScript 7.1 target; close releases it.
+  hosts        *shimcompiler.ProjectHosts
+  checker      *shimchecker.Checker
+  identity     publicrule.ProjectIdentity
+  projectCycle *projectCycle
   // projectRoots memoizes projectSourceFileNames, which resolves every
   // selected file's path and therefore costs filesystem work. The tsconfig
   // selection cannot change while one program is loaded — a config edit or a
@@ -107,6 +110,14 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
   if !filepath.IsAbs(resolved) {
     resolved = filepath.Join(cwd, resolved)
   }
+  configFile, ok := shimtspath.TryRootedFilePathFromAbsolute(resolved)
+  if !ok {
+    return nil, nil, fmt.Errorf("loadProgram: tsconfig path is not absolute: %s", resolved)
+  }
+  cwdDir, ok := rootedDirectory(cwd)
+  if !ok {
+    return nil, nil, fmt.Errorf("loadProgram: cwd is not absolute: %s", cwd)
+  }
 
   var fs vfs.FS = bundled.WrapFS(cachedvfs.From(osvfs.FS()))
   var observer *inputObservationFS
@@ -116,18 +127,19 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
     reader = newProjectInputReader(observer)
     fs = observer
   }
-  host := shimcompiler.NewCompilerHost(cwd, fs, bundled.LibPath(), nil, nil)
-  argumentHost := host
+  // Forwarded flags convert relative values against their own argv base, so
+  // only the parser's directory changes.
+  argumentDir := cwdDir
   if options.tsgoArgsCwd != "" {
     argumentCwd := options.tsgoArgsCwd
     if !filepath.IsAbs(argumentCwd) {
       argumentCwd = filepath.Join(cwd, argumentCwd)
     }
-    if argumentCwd != cwd {
-      argumentHost = shimcompiler.NewCompilerHost(argumentCwd, fs, bundled.LibPath(), nil, nil)
+    if argumentDir, ok = rootedDirectory(argumentCwd); !ok {
+      return nil, nil, fmt.Errorf("loadProgram: tsgo args cwd is not absolute: %s", argumentCwd)
     }
   }
-  commandLine, cliDiags := parseTsgoArgs(options.tsgoArgs, argumentHost)
+  commandLine, cliDiags := parseTsgoArgs(options.tsgoArgs, fs, argumentDir)
   if len(cliDiags) > 0 {
     return nil, cliDiags, nil
   }
@@ -140,10 +152,10 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
     cliOptions = &shimcore.CompilerOptions{}
   }
   parsed, parseDiags := tsoptions.GetParsedCommandLineOfConfigFile(
-    resolved,
+    configFile,
     cliOptions,
     tsoptions.CommandLineRawOptions(commandLine),
-    argumentHost,
+    tsoptions.NewParseConfigHost(fs, argumentDir),
     nil,
   )
   if parsed == nil {
@@ -155,9 +167,13 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
   if len(parsed.Errors) > 0 {
     return nil, parsed.Errors, nil
   }
-  if err := applySemanticConfigPath(parsed, options.semanticConfigPath); err != nil {
+  parsed, semanticDiags, err := parseSemanticConfig(parsed, options.semanticConfigPath, commandLine, fs)
+  if err != nil {
     return nil, nil, err
   }
+  if len(semanticDiags) > 0 {
+    return nil, semanticDiags, nil
+  }
   if options.forceNoEmit {
     forceNoEmit(parsed)
   }
@@ -165,9 +181,13 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
     forceEmit(parsed)
   }
   if options.outDir != "" {
-    overrideOutDir(cwd, parsed, options.outDir)
+    overrideOutDir(cwdDir, parsed, options.outDir)
   }
   applyThreading(parsed, options.singleThreaded, options.checkers)
+  // The parsed project decides whether its content mappers run, so the
+  // Program's host is built only now, over the same filesystem.
+  hosts := shimcompiler.NewProjectHosts(parsed)
+  host := hosts.Host(cwdDir, fs, shimtspath.RootedDirectoryPath(bundled.LibPath()))
 
   // Keep the user's checker pool intact for parallel semantic diagnostics.
   // Type-aware lint rules cannot borrow one member of that pool: they walk
@@ -177,11 +197,7 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*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,
-    UseSourceOfProjectReference: true,
-  })
+  tsProgram := shimcompiler.NewProgram(shimcompiler.NewProgramOptions(parsed, host, true))
   if tsProgram == nil {
     return nil, nil, errors.New("compiler.NewProgram returned nil")
   }
@@ -195,21 +211,53 @@ func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program
     inputReader:   reader,
     tsProgram:     tsProgram,
     parsed:        parsed,
+    hosts:         hosts,
     checker:       checker,
     identity:      normalizeProjectIdentity(options.projectIdentity, cwd, resolved),
   }, nil, nil
 }
 
-func applySemanticConfigPath(parsed *tsoptions.ParsedCommandLine, semanticConfigPath string) error {
+// parseSemanticConfig makes the user-authored config the parsed project when
+// a generated wrapper extends it from a scratch directory. TypeScript-Go
+// anchors resolution, automatic type discovery and the Program's current
+// directory at the directory of the config file it parsed, so the wrapper must
+// not become the project. The wrapper's merged options, which already carry the
+// user config's own options, the overlay and the command line, take
+// command-line precedence over a fresh parse of the user config; the command
+// line's raw options keep its resets.
+func parseSemanticConfig(wrapper *tsoptions.ParsedCommandLine, semanticConfigPath string, commandLine *tsoptions.ParsedCommandLine, fs vfs.FS) (*tsoptions.ParsedCommandLine, []*shimast.Diagnostic, error) {
   configured := strings.TrimSpace(semanticConfigPath)
   if configured == "" {
-    return nil
+    return wrapper, nil, nil
   }
   if !filepath.IsAbs(configured) {
-    return fmt.Errorf("linthost: semantic config path must be absolute: %s", configured)
+    return nil, nil, fmt.Errorf("linthost: semantic config path must be absolute: %s", configured)
   }
-  parsed.ParsedConfig.CompilerOptions.ConfigFilePath = shimtspath.ResolvePath(configured)
-  return nil
+  semanticConfig, ok := shimtspath.TryRootedFilePathFromAbsolute(configured)
+  if !ok {
+    return nil, nil, fmt.Errorf("linthost: semantic config path cannot be rooted: %s", configured)
+  }
+  wrapperConfig := wrapper.CompilerOptions().ConfigFilePath
+  if wrapperConfig != "" && shimtspath.CompareFilePaths(vfs.CaseSensitivityOf(fs), wrapperConfig, semanticConfig) == 0 {
+    return wrapper, nil, nil
+  }
+  parsed, diagnostics := tsoptions.GetParsedCommandLineOfConfigFile(
+    semanticConfig,
+    wrapper.CompilerOptions().Clone(),
+    tsoptions.CommandLineRawOptions(commandLine),
+    tsoptions.NewParseConfigHost(fs, shimtspath.FileDirectory(semanticConfig)),
+    nil,
+  )
+  if parsed == nil {
+    return nil, nil, fmt.Errorf("tsoptions: parsed command line was nil for %s", string(semanticConfig))
+  }
+  if len(diagnostics) > 0 {
+    return nil, diagnostics, nil
+  }
+  if len(parsed.Errors) > 0 {
+    return nil, parsed.Errors, nil
+  }
+  return parsed, nil, nil
 }
 
 func normalizeProjectIdentity(
@@ -394,13 +442,17 @@ func (p *program) runCycleOver(engine *Engine, files []*shimast.SourceFile) []*F
   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.
+// close drops the standalone lint checker and stops the project's
+// content-mapper processes. Safe to call on a nil receiver and idempotent after
+// the first call. A mapper that fails to stop has already been killed, and no
+// lint result depends on its exit, so the close error is not reported.
 func (p *program) close() {
   if p == nil {
     return
   }
   p.checker = nil
+  _ = p.hosts.Close()
+  p.hosts = nil
 }
 
 // sourceFileByPath returns the resident Program's source file whose name matches
@@ -415,7 +467,7 @@ func (p *program) sourceFileByPath(absPath string) *shimast.SourceFile {
     if file == nil {
       continue
     }
-    if filepath.ToSlash(file.FileName()) == normalized {
+    if filepath.ToSlash(string(file.FileName())) == normalized {
       return file
     }
   }
@@ -432,18 +484,23 @@ func (p *program) sourceFileByPath(absPath string) *shimast.SourceFile {
 // when the edit reshaped the import graph, and that rebuilt Program is still
 // correct, but callers use the reused flag to distinguish incremental updates
 // from full Program reconstruction in product telemetry.
+// It returns false, leaving the Program unchanged, when absPath has no rooted
+// file name.
 func (p *program) applyChange(absPath string) bool {
   if p == nil || p.tsProgram == nil {
     return false
   }
-  name := absPath
-  if file := p.sourceFileByPath(absPath); file != nil {
-    name = file.FileName()
+  name, ok := p.changedFileName(absPath)
+  if !ok {
+    return false
   }
   fs := bundled.WrapFS(cachedvfs.From(osvfs.FS()))
-  host := shimcompiler.NewCompilerHost(p.cwd, fs, bundled.LibPath(), nil, nil)
-  changed := shimtspath.ToPath(name, p.cwd, fs.UseCaseSensitiveFileNames())
-  newProg, reused := p.tsProgram.UpdateProgram(changed, host, nil)
+  // The new host keeps the Program's content mappers, so a mapped file is
+  // still transformed by the processes the first generation started.
+  host := p.hosts.Host(shimtspath.RootedDirectoryPath(p.cwd), fs, shimtspath.RootedDirectoryPath(bundled.LibPath()))
+  // The second result is the changed file as host parsed it, returned so a
+  // host with a parse cache can release it; this host parses without one.
+  newProg, _, reused := shimcompiler.UpdateProgram(p.tsProgram, shimcompiler.ProgramPathKey(p.tsProgram, name), host)
   if newProg != nil {
     // An updated generation cannot inherit a one-shot check's observed inputs.
     // Resident commands currently negotiate no check sidecar; keep an explicit
@@ -464,6 +521,31 @@ func (p *program) applyChange(absPath string) bool {
   return reused
 }
 
+// changedFileName names the file absPath addresses as the compiler keys it. The
+// resident Program's own spelling wins; otherwise absPath resolves against the
+// Program's cwd. It reports false when no rooted name exists.
+func (p *program) changedFileName(absPath string) (shimtspath.RootedFilePath, bool) {
+  if file := p.sourceFileByPath(absPath); file != nil {
+    return file.FileName(), true
+  }
+  cwd, ok := rootedDirectory(p.cwd)
+  if !ok || absPath == "" {
+    return "", false
+  }
+  return shimtspath.ToRootedFilePath(absPath, cwd), true
+}
+
+// rootedDirectory gives an absolute native directory the compiler's rooted
+// identity. A relative directory has no such identity, so it reports false
+// instead of resolving against an implicit working directory.
+func rootedDirectory(absolute string) (shimtspath.RootedDirectoryPath, bool) {
+  path, ok := shimtspath.TryRootedPathFromAbsolute(absolute)
+  if !ok {
+    return "", false
+  }
+  return shimtspath.RootedDirectoryPathFromPath(path), true
+}
+
 // userSourceFiles returns the source files the lint engine reads for one cycle:
 // the tsconfig-selected TS/JS roots plus every TypeScript source the Program
 // pulled in through an import.
@@ -495,7 +577,7 @@ func (p *program) userSourceFiles() []*shimast.SourceFile {
     if f == nil {
       continue
     }
-    if p.selectedByProject(roots, f.FileName()) {
+    if p.selectedByProject(roots, string(f.FileName())) {
       out = append(out, f)
       continue
     }
@@ -516,7 +598,7 @@ func (p *program) projectSourceFiles() []*shimast.SourceFile {
     if f == nil {
       continue
     }
-    if !p.selectedByProject(roots, f.FileName()) {
+    if !p.selectedByProject(roots, string(f.FileName())) {
       continue
     }
     out = append(out, f)
@@ -555,14 +637,14 @@ func (p *program) projectSourceFileNames() map[string]struct{} {
   out := make(map[string]struct{})
   if p.parsed != nil && p.parsed.ParsedConfig != nil {
     for _, fileName := range p.parsed.ParsedConfig.FileNames {
-      if !isLintSourceFileName(fileName) {
+      if !isLintSourceFileName(string(fileName)) {
         continue
       }
-      if bundled.IsBundled(fileName) {
-        out[fileName] = struct{}{}
+      if bundled.IsBundled(string(fileName)) {
+        out[string(fileName)] = struct{}{}
         continue
       }
-      absolute := absoluteProjectPath(p.cwd, fileName)
+      absolute := absoluteProjectPath(p.cwd, string(fileName))
       out[canonicalProjectPath(p.cwd, absolute)] = struct{}{}
       out[canonicalProjectPath(p.cwd, realProjectPath(absolute))] = struct{}{}
     }
@@ -617,7 +699,7 @@ func (p *program) projectWritableFindings(findings []*Finding) []*Finding {
     if finding == nil || finding.File == nil {
       continue
     }
-    if !p.selectedByProject(roots, finding.File.FileName()) {
+    if !p.selectedByProject(roots, string(finding.File.FileName())) {
       continue
     }
     out = append(out, finding)
@@ -638,7 +720,7 @@ func isImportedLintSourceFile(file *shimast.SourceFile) bool {
   if file == nil || file.IsDeclarationFile {
     return false
   }
-  return isTypeScriptSourceFileName(file.FileName())
+  return isTypeScriptSourceFileName(string(file.FileName()))
 }
 
 // isLintSourceFileName reports whether a tsconfig-selected file is a lint/format
@@ -695,7 +777,7 @@ func (p *program) programDiagnostics() []*shimast.Diagnostic {
 func (p *program) findSourceFile(target string) *shimast.SourceFile {
   want := shimtspath.NormalizePath(target)
   for _, file := range p.tsProgram.SourceFiles() {
-    if shimtspath.NormalizePath(file.FileName()) == want {
+    if shimtspath.NormalizePath(string(file.FileName())) == want {
       return file
     }
   }
@@ -728,11 +810,11 @@ func forceNoEmit(parsed *tsoptions.ParsedCommandLine) {
 // loadProgram merges over the tsconfig — so a flag like `ttsc --strict` reaches
 // the in-process lint program even though @ttsc/lint never shells out to
 // `tsgo`. Returns nil when there are no forwarded flags.
-func parseTsgoArgs(args []string, host shimcompiler.CompilerHost) (*tsoptions.ParsedCommandLine, []*shimast.Diagnostic) {
+func parseTsgoArgs(args []string, fs vfs.FS, cwd shimtspath.RootedDirectoryPath) (*tsoptions.ParsedCommandLine, []*shimast.Diagnostic) {
   if len(args) == 0 {
     return nil, nil
   }
-  cli := tsoptions.ParseCommandLine(args, host)
+  cli := tsoptions.ParseCommandLineAt(args, fs, cwd)
   if cli == nil {
     return nil, nil
   }
@@ -764,19 +846,15 @@ func applyThreading(parsed *tsoptions.ParsedCommandLine, singleThreaded bool, ch
   }
 }
 
-// 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
-// compatibility.
-func overrideOutDir(cwd string, parsed *tsoptions.ParsedCommandLine, outDir string) {
+// overrideOutDir replaces the parsed config's OutDir with outDir, which the
+// caller has checked is nonempty. Relative values resolve against cwd, and
+// absolute values keep their location. The compiler stores the result as a
+// rooted directory, which expresses the forward-slash form tsgo expects.
+func overrideOutDir(cwd shimtspath.RootedDirectoryPath, parsed *tsoptions.ParsedCommandLine, outDir string) {
   if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
     return
   }
-  if filepath.IsAbs(outDir) {
-    parsed.ParsedConfig.CompilerOptions.OutDir = filepath.ToSlash(outDir)
-    return
-  }
-  parsed.ParsedConfig.CompilerOptions.OutDir = filepath.ToSlash(filepath.Join(cwd, outDir))
+  parsed.ParsedConfig.CompilerOptions.OutDir = shimtspath.ToRootedDirectoryPath(outDir, cwd)
 }
 
 // projectInputReaders exposes only this loaded generation's reader. Manual or

package/linthost/imported_tsx_source_joins_the_read_scope_test.go

@@ -52,7 +52,7 @@ func TestImportedTsxSourceJoinsTheReadScope(t *testing.T) {
 
   names := make([]string, 0)
   for _, file := range prog.userSourceFiles() {
-    rel, err := filepath.Rel(root, file.FileName())
+    rel, err := filepath.Rel(root, string(file.FileName()))
     if err != nil {
       t.Fatal(err)
     }

package/linthost/input_observation.go

@@ -113,7 +113,7 @@ type observedInput struct {
 // released; returned listing/text sizes still determine retained bytes.
 type inputObservationFS struct {
   vfs.FS
-  caseSensitive        bool
+  caseSensitivity      shimtspath.CaseSensitivity
   mu                   sync.Mutex
   observations         map[string]observedInput
   observationOrder     []string
@@ -125,7 +125,7 @@ type inputObservationFS struct {
 func newInputObservationFS(inner vfs.FS) *inputObservationFS {
   return &inputObservationFS{
     FS:                   inner,
-    caseSensitive:        inner.UseCaseSensitiveFileNames(),
+    caseSensitivity:      vfs.CaseSensitivityOf(inner),
     observations:         map[string]observedInput{},
     observationSpellings: map[string]string{},
   }
@@ -133,34 +133,34 @@ func newInputObservationFS(inner vfs.FS) *inputObservationFS {
 
 // FileExists records the returned existence answer; a true answer additionally
 // records the same VFS's identity spelling without inventing file contents.
-func (fs *inputObservationFS) FileExists(path string) bool {
+func (fs *inputObservationFS) FileExists(path shimtspath.RootedFilePath) bool {
   exists := fs.FS.FileExists(path)
   proof := transformInputObservation{FileExists: boolPointer(exists)}
   if exists {
     // Existence participates in resolution, but only ReadFile returns bytes
     // that can influence the resident Program. Do not duplicate every
     // resolver probe with an eager file read.
-    proof.Realpath = fs.currentRealpath(path)
+    proof.Realpath = fs.currentRealpath(shimtspath.RootedPath(path))
   }
-  fs.observe(path, observedInput{proof: proof})
+  fs.observe(string(path), observedInput{proof: proof})
   return exists
 }
 
 // ReadFile hashes the text actually returned by the compiler VFS. A failed read
 // records failure without hashing a second read or guessing the path's kind.
-func (fs *inputObservationFS) ReadFile(path string) (string, bool) {
+func (fs *inputObservationFS) ReadFile(path shimtspath.RootedFilePath) (string, bool) {
   contents, ok := fs.FS.ReadFile(path)
   if ok {
     digest := sha256.Sum256([]byte(contents))
     hash := hex.EncodeToString(digest[:])
-    fs.observe(path, observedInput{
+    fs.observe(string(path), observedInput{
       proof: transformInputObservation{
         ReadFile: &transformInputReadObservation{OK: true, Hash: hash},
-        Realpath: fs.currentRealpath(path),
+        Realpath: fs.currentRealpath(shimtspath.RootedPath(path)),
       },
     })
   } else {
-    fs.observe(path, observedInput{
+    fs.observe(string(path), observedInput{
       proof: transformInputObservation{
         ReadFile: &transformInputReadObservation{OK: false},
       },
@@ -171,21 +171,21 @@ func (fs *inputObservationFS) ReadFile(path string) (string, bool) {
 
 // DirectoryExists records existence independently of FileExists, since a
 // false file predicate and a true directory predicate are compatible.
-func (fs *inputObservationFS) DirectoryExists(path string) bool {
+func (fs *inputObservationFS) DirectoryExists(path shimtspath.RootedDirectoryPath) bool {
   exists := fs.FS.DirectoryExists(path)
   proof := transformInputObservation{DirectoryExists: boolPointer(exists)}
   if exists {
-    proof.Realpath = fs.currentRealpath(path)
+    proof.Realpath = fs.currentRealpath(shimtspath.RootedPath(path))
   }
-  fs.observe(path, observedInput{proof: proof})
+  fs.observe(string(path), observedInput{proof: proof})
   return exists
 }
 
 // GetAccessibleEntries copies the returned lists before retaining them so the
 // caller cannot mutate the witness. It does not add an unconsumed traversal.
-func (fs *inputObservationFS) GetAccessibleEntries(path string) vfs.Entries {
+func (fs *inputObservationFS) GetAccessibleEntries(path shimtspath.RootedDirectoryPath) vfs.Entries {
   entries := fs.FS.GetAccessibleEntries(path)
-  fs.observe(path, observedInput{
+  fs.observe(string(path), observedInput{
     proof: transformInputObservation{
       AccessibleEntries: &transformInputEntriesObservation{
         Directories: append([]string{}, entries.Directories...),
@@ -198,16 +198,16 @@ func (fs *inputObservationFS) GetAccessibleEntries(path string) vfs.Entries {
 
 // Stat records the supplied VFS's nil/file/directory distinction and its
 // identity spelling for existing objects, preserving the returned FileInfo.
-func (fs *inputObservationFS) Stat(path string) vfs.FileInfo {
+func (fs *inputObservationFS) Stat(path shimtspath.RootedPath) vfs.FileInfo {
   info := fs.FS.Stat(path)
   kind := "missing"
   if info == nil {
-    fs.observe(path, observedInput{
+    fs.observe(string(path), observedInput{
       proof: transformInputObservation{Stat: &kind},
     })
   } else if info.IsDir() {
     kind = "directory"
-    fs.observe(path, observedInput{
+    fs.observe(string(path), observedInput{
       proof: transformInputObservation{
         Stat:     &kind,
         Realpath: fs.currentRealpath(path),
@@ -215,7 +215,7 @@ func (fs *inputObservationFS) Stat(path string) vfs.FileInfo {
     })
   } else {
     kind = "file"
-    fs.observe(path, observedInput{
+    fs.observe(string(path), observedInput{
       proof: transformInputObservation{
         Stat:     &kind,
         Realpath: fs.currentRealpath(path),
@@ -227,18 +227,18 @@ func (fs *inputObservationFS) Stat(path string) vfs.FileInfo {
 
 // Realpath records the adapter's answer and returns it unchanged; a lexical
 // fallback remains an adapter answer, not separately proven physical identity.
-func (fs *inputObservationFS) Realpath(path string) string {
+func (fs *inputObservationFS) Realpath(path shimtspath.RootedPath) shimtspath.RootedPath {
   realpath := fs.FS.Realpath(path)
-  fs.observe(path, observedInput{
-    proof: transformInputObservation{Realpath: realpathObservation(realpath)},
+  fs.observe(string(path), observedInput{
+    proof: transformInputObservation{Realpath: realpathObservation(string(realpath))},
   })
   return realpath
 }
 
 // currentRealpath obtains the identity predicate beside an existing-object
 // query without routing that supporting call back through the observer.
-func (fs *inputObservationFS) currentRealpath(path string) *transformInputRealpathObservation {
-  return realpathObservation(fs.FS.Realpath(path))
+func (fs *inputObservationFS) currentRealpath(path shimtspath.RootedPath) *transformInputRealpathObservation {
+  return realpathObservation(string(fs.FS.Realpath(path)))
 }
 
 // realpathObservation distinguishes an empty adapter result from its cleaned
@@ -264,10 +264,7 @@ func (fs *inputObservationFS) observationKey(path string) string {
   if !filepath.IsAbs(path) {
     return ""
   }
-  return shimtspath.GetCanonicalFileName(
-    shimtspath.NormalizePath(path),
-    fs.caseSensitive,
-  )
+  return shimtspath.Canonicalize(fs.caseSensitivity, shimtspath.NormalizePath(path))
 }
 
 // observe merges under the ledger lock and preserves first lexical spelling.

package/linthost/invalid_contributor_range_cannot_panic_inline_directive_filtering_test.go

@@ -21,7 +21,7 @@ func TestInvalidContributorRangeCannotPanicInlineDirectiveFiltering(t *testing.T
 const value = 1;
 `)
   contributor := &boundedDiagnosticRangeContributor{
-    spans: map[string][2]int{file.FileName(): {999, 1200}},
+    spans: map[string][2]int{string(file.FileName()): {999, 1200}},
   }
   metadata, err := inspectContributor(contributor)
   if err != nil {

package/linthost/lint_corpus_filename_separators_share_materialized_source_identity_test.go

@@ -70,7 +70,7 @@ func TestLintCorpusFilenameSeparatorsShareMaterializedSourceIdentity(t *testing.
       finding := findings[0]
       start := strings.Index(source, "var legacy")
       end := start + len("var legacy = 1;")
-      if finding.Pos != start || finding.End != end || finding.File.FileName() != filepath.ToSlash(location) {
+      if finding.Pos != start || finding.End != end || string(finding.File.FileName()) != filepath.ToSlash(location) {
         t.Fatalf("main source identity/range: got %s [%d,%d), want %s [%d,%d)", finding.File.FileName(), finding.Pos, finding.End, filepath.ToSlash(location), start, end)
       }
     })

package/linthost/load_config_resolver_compact_globs_preserve_entry_policy_test.go

@@ -79,7 +79,7 @@ func TestLoadConfigResolverCompactGlobsPreserveEntryPolicy(t *testing.T) {
   scoped := filepath.Join(root, "scoped.config.json")
   writeFile(t, scoped, `{"files":["{src,test}/**/{main,unit}.ts"],"ignores":["src/{local,other}/**"],"format":{"severity":"off","semi":false}}`)
   scopedResolver := load(scoped)
-  selected := (formatCommandResolver{inner: scopedResolver}).ResolveRules(main.FileName())
+  selected := (formatCommandResolver{inner: scopedResolver}).ResolveRules(string(main.FileName()))
   if selected.OutOfScope || selected.Ignored || selected.Rules.Severity("format/semi") != SeverityWarn || string(selected.RuleOptions("format/semi")) != `{"prefer":"never"}` {
     t.Errorf("scoped formatter positive did not execute its selected policy: %+v options=%s", selected, selected.RuleOptions("format/semi"))
   }
@@ -91,7 +91,7 @@ func TestLoadConfigResolverCompactGlobsPreserveEntryPolicy(t *testing.T) {
   }
   writeFile(t, base, `{"rules":{"no-var":"error"}}`)
   reloaded := load(final)
-  if got := reloaded.ResolveRules(ignored.FileName()); got.Ignored || got.Rules.Severity("no-var") != SeverityError {
+  if got := reloaded.ResolveRules(string(ignored.FileName())); got.Ignored || got.Rules.Severity("no-var") != SeverityError {
     t.Errorf("changed global ignore did not refresh: %+v", got)
   }
 }

package/linthost/load_program_keeps_checker_pool_for_type_aware_rules_test.go

@@ -122,7 +122,7 @@ func TestLoadProgramKeepsCheckerPoolForTypeAwareRules(t *testing.T) {
     t.Fatalf("unexpected generated-wrapper diagnostics: %#v", generatedDiags)
   }
   defer generated.close()
-  if got := generated.tsProgram.Options().ConfigFilePath; got != shimtspath.ResolvePath(semanticConfig) {
+  if got := string(generated.tsProgram.Options().ConfigFilePath); got != shimtspath.ResolvePath(semanticConfig) {
     t.Fatalf("generated wrapper semantic config = %q, want %q", got, shimtspath.ResolvePath(semanticConfig))
   }
 
@@ -143,7 +143,7 @@ func TestLoadProgramKeepsCheckerPoolForTypeAwareRules(t *testing.T) {
   if len(coldLSPDiags) != 0 {
     t.Fatalf("unexpected cold LSP diagnostics: %#v", coldLSPDiags)
   }
-  if got := coldLSP.tsProgram.Options().ConfigFilePath; got != shimtspath.ResolvePath(semanticConfig) {
+  if got := string(coldLSP.tsProgram.Options().ConfigFilePath); got != shimtspath.ResolvePath(semanticConfig) {
     t.Fatalf("cold LSP semantic config = %q, want %q", got, shimtspath.ResolvePath(semanticConfig))
   }
 
@@ -155,7 +155,7 @@ func TestLoadProgramKeepsCheckerPoolForTypeAwareRules(t *testing.T) {
   if len(residentLSPDiags) != 0 {
     t.Fatalf("unexpected resident LSP diagnostics: %#v", residentLSPDiags)
   }
-  if got := residentLSP.tsProgram.Options().ConfigFilePath; got != shimtspath.ResolvePath(semanticConfig) {
+  if got := string(residentLSP.tsProgram.Options().ConfigFilePath); got != shimtspath.ResolvePath(semanticConfig) {
     t.Fatalf("resident LSP semantic config = %q, want %q", got, shimtspath.ResolvePath(semanticConfig))
   }
   resident.invalidate()
@@ -168,7 +168,7 @@ func TestLoadProgramKeepsCheckerPoolForTypeAwareRules(t *testing.T) {
     t.Fatalf("unexpected unmarked-wrapper diagnostics: %#v", unmarkedDiags)
   }
   defer unmarked.close()
-  if got := unmarked.tsProgram.Options().ConfigFilePath; got != shimtspath.ResolvePath(generatedConfig) {
+  if got := string(unmarked.tsProgram.Options().ConfigFilePath); got != shimtspath.ResolvePath(generatedConfig) {
     t.Fatalf("unmarked wrapper inherited ambient semantic config = %q, want %q", got, shimtspath.ResolvePath(generatedConfig))
   }
   invalid, _, err := loadProgram(root, generatedConfig, loadProgramOptions{semanticConfigPath: "relative.json"})

package/linthost/lsp.go

@@ -20,6 +20,7 @@ import (
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
   shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 
   publicrule "github.com/samchon/ttsc/packages/lint/rule"
 )
@@ -602,7 +603,7 @@ func filterFindingsForPath(findings []*Finding, target string) []*Finding {
     if finding == nil || finding.File == nil {
       continue
     }
-    if canonicalProjectPath("", realProjectPath(finding.File.FileName())) == target {
+    if canonicalProjectPath("", realProjectPath(string(finding.File.FileName()))) == target {
       out = append(out, finding)
     }
   }
@@ -631,7 +632,7 @@ func lspRelatedInformationForFinding(finding *Finding) []lspRelatedInformation {
   if finding == nil || len(finding.RelatedInformation) == 0 || finding.File == nil {
     return nil
   }
-  uri := fileURL(finding.File.FileName())
+  uri := fileURL(string(finding.File.FileName()))
   out := make([]lspRelatedInformation, 0, len(finding.RelatedInformation))
   for _, item := range finding.RelatedInformation {
     out = append(out, lspRelatedInformation{
@@ -1185,9 +1186,13 @@ func lspFormatBuffer(content string, opts *lspCommandOptions) (*lspWorkspaceEdit
 
   text := content
   converged := false
-  // The tsgo parser asserts on normalized (forward-slash) absolute paths;
-  // `target` comes from filepath.Abs and carries backslashes on Windows.
-  parseName := filepath.ToSlash(target)
+  // The parser takes a rooted file name: the normalized, forward-slash form of
+  // `target`, which filePathFromURI made absolute.
+  parseName, ok := shimtspath.TryRootedFilePathFromAbsolute(target)
+  if !ok {
+    fmt.Fprintf(os.Stderr, "@ttsc/lint: LSP format target is not a rooted path: %s\n", target)
+    return nil, 2
+  }
   for pass := 0; pass < maxFormatPasses; pass++ {
     file := shimparser.ParseSourceFile(shimast.SourceFileParseOptions{FileName: parseName}, text, scriptKind)
     if file == nil || len(file.Diagnostics()) > 0 || len(file.JSDiagnostics()) > 0 {

package/linthost/no_floating_promises_javascript_generic_defaults_test.go

@@ -84,7 +84,7 @@ export class JsSafeCatch {
   }
   var file *shimast.SourceFile
   for _, candidate := range prog.userSourceFiles() {
-    if filepath.Base(candidate.FileName()) == "main.ts" {
+    if filepath.Base(string(candidate.FileName())) == "main.ts" {
       file = candidate
       break
     }

package/linthost/no_floating_promises_rejects_inapplicable_generic_receiver_branches_test.go

@@ -228,7 +228,7 @@ function checkUncertainArray<U>(
       if diagnostic == nil || diagnostic.Code() != 2349 || diagnostic.File() == nil {
         continue
       }
-      fileName := strings.ReplaceAll(diagnostic.File().FileName(), "\\", "/")
+      fileName := strings.ReplaceAll(string(diagnostic.File().FileName()), "\\", "/")
       if fileName != "main.ts" && !strings.HasSuffix(fileName, "/main.ts") {
         continue
       }