@ttsc/lint 0.33.1 → 0.34.1

package/go.mod

@@ -32,9 +32,9 @@ require (
 )
 
 require (
-	github.com/go-json-experiment/json v0.0.0-20260601182631-00ed12fed2a6 // indirect
+	github.com/go-json-experiment/json v0.0.0-20260623181947-01eb4420fa68 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
-	github.com/microsoft/typescript-go v0.0.0-20260610182825-7fc57c005063 // indirect
+	github.com/microsoft/typescript-go v0.0.0-20260708042240-2bd066d87f5b // indirect
 	github.com/zeebo/xxh3 v1.1.0 // indirect
 	golang.org/x/sync v0.21.0 // indirect
 	golang.org/x/sys v0.46.0 // indirect

package/linthost/ast_helpers.go

@@ -596,8 +596,8 @@ func canonicalValueSymbol(ctx *Context, identifier *shimast.Node) *shimast.Symbo
   if symbol == nil {
     return nil
   }
-  if symbol.Flags&shimast.SymbolFlagsExportValue != 0 && symbol.ExportSymbol != nil {
-    symbol = symbol.ExportSymbol
+  if shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsExportValue != 0 && shimast.SymbolExportSymbolOf(symbol) != nil {
+    symbol = shimast.SymbolExportSymbolOf(symbol)
   }
   return ctx.Checker.GetMergedSymbol(symbol)
 }

package/linthost/base_chain_walk_crosses_generic_boundary_test.go

@@ -111,7 +111,7 @@ func classSymbol(t *testing.T, prog *program, name string) *shimast.Symbol {
       continue
     }
     for _, stmt := range file.Statements.Nodes {
-      if sym := stmt.Symbol(); sym != nil && sym.Name == name {
+      if sym := stmt.Symbol(); sym != nil && shimast.SymbolNameOf(sym) == name {
         return sym
       }
     }
@@ -137,7 +137,7 @@ func collectAncestorNames(c *shimchecker.Checker, start *shimchecker.Type, bridg
     }
     seen[t] = true
     if sym := shimchecker.Type_getTypeNameSymbol(t); sym != nil {
-      found[sym.Name] = true
+      found[shimast.SymbolNameOf(sym)] = true
     }
     if t.ObjectFlags()&shimchecker.ObjectFlagsClassOrInterface == 0 {
       return // not safe to feed to getBaseTypes
@@ -153,7 +153,7 @@ func collectAncestorNames(c *shimchecker.Checker, start *shimchecker.Type, bridg
       // base is a generic Reference: record the boundary name, then cross it
       // only when bridging is allowed.
       if sym := shimchecker.Type_getTypeNameSymbol(base); sym != nil {
-        found[sym.Name] = true
+        found[shimast.SymbolNameOf(sym)] = true
         if bridge {
           visit(shimchecker.Checker_getDeclaredTypeOfSymbol(c, sym))
         }

package/linthost/check_observations.go

@@ -60,22 +60,22 @@ func (p *program) checkGraph() *lintCheckGraph {
   graph := &lintCheckGraph{Edges: map[string][]string{}, Globals: []string{}, Configs: []string{}, ResolutionInputs: []string{}, InputObservations: map[string]transformInputObservation{}, InputHashes: map[string]*string{}, InputRealpaths: map[string]*string{}, InputProofFailures: map[string]string{}, UseCaseSensitiveFileNames: p.tsProgram.UseCaseSensitiveFileNames()}
   realized := map[string]bool{}
   for _, file := range p.tsProgram.SourceFiles() {
-    if file == nil || strings.HasPrefix(file.FileName(), "bundled:///") {
+    if file == nil || strings.HasPrefix(string(file.FileName()), "bundled:///") {
       continue
     }
-    key := lintInputKey(p.cwd, file.FileName())
-    realized[file.FileName()] = true
+    key := lintInputKey(p.cwd, string(file.FileName()))
+    realized[string(file.FileName())] = true
     targets := []string{}
-    // The shim returns canonical tspath.Path values encoded as strings, not
-    // filenames. Preserve that exact identity and recover this Program's
-    // resident source spelling; unresolved candidates are not realized edges.
+    // The shim returns canonical tspath.PathKey values, not filenames. Preserve
+    // that exact key and recover this Program's resident source spelling;
+    // unresolved candidates are not realized edges.
     for _, referenced := range shimcompiler.GetReferencedFilePaths(p.tsProgram, file) {
-      source := p.tsProgram.GetSourceFileByPath(shimtspath.Path(referenced))
-      if source == nil || source == file || strings.HasPrefix(source.FileName(), "bundled:///") {
+      source := p.tsProgram.GetSourceFileByPath(shimtspath.PathKey(referenced))
+      if source == nil || source == file || strings.HasPrefix(string(source.FileName()), "bundled:///") {
         continue
       }
-      realized[source.FileName()] = true
-      targets = append(targets, lintInputKey(p.cwd, source.FileName()))
+      realized[string(source.FileName())] = true
+      targets = append(targets, lintInputKey(p.cwd, string(source.FileName())))
     }
     sort.Strings(targets)
     graph.Edges[key] = targets
@@ -86,12 +86,12 @@ func (p *program) checkGraph() *lintCheckGraph {
   sort.Strings(graph.Globals)
   if p.parsed != nil && p.parsed.ConfigFile != nil {
     if file := p.parsed.ConfigFile.SourceFile; file != nil {
-      realized[file.FileName()] = true
-      graph.Configs = append(graph.Configs, lintInputKey(p.cwd, file.FileName()))
+      realized[string(file.FileName())] = true
+      graph.Configs = append(graph.Configs, lintInputKey(p.cwd, string(file.FileName())))
     }
     for _, file := range p.parsed.ExtendedSourceFiles() {
-      realized[file] = true
-      graph.Configs = append(graph.Configs, lintInputKey(p.cwd, file))
+      realized[string(file)] = true
+      graph.Configs = append(graph.Configs, lintInputKey(p.cwd, string(file)))
     }
   }
   // Conservatively universalize actual compiler predicates. This needs no

package/linthost/check_observations_retains_failed_program_and_raw_inputs_test.go

@@ -11,6 +11,7 @@ import (
   "reflect"
   "testing"
 
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
   publicrule "github.com/samchon/ttsc/packages/lint/rule"
 )
 
@@ -125,7 +126,7 @@ func TestCheckObservationsRetainsFailedProgramAndRawInputs(t *testing.T) {
   if err != nil || !bytes.Equal(actual, raw) {
     t.Fatalf("raw reader changed bytes: %x %v", actual, err)
   }
-  decoded, ok := prog.inputObserver.ReadFile(document)
+  decoded, ok := prog.inputObserver.ReadFile(shimtspath.RootedFilePathFromAbsolute(document))
   if !ok || decoded != "# Before\n" {
     t.Fatalf("compiler text changed its decoder contract: %q %v", decoded, ok)
   }
@@ -191,7 +192,7 @@ func TestCheckObservationsRetainsFailedProgramAndRawInputs(t *testing.T) {
   if directory.Kind != "directory" || directory.Version != 1 || directory.Digest != hex.EncodeToString(directorySum[:]) || !directory.IdentityStable {
     t.Fatalf("native listing lost authored membership proof: %#v", directory)
   }
-  compilerListing := prog.inputObserver.GetAccessibleEntries(tree)
+  compilerListing := prog.inputObserver.GetAccessibleEntries(shimtspath.RootedDirectoryPathFromAbsolute(tree))
   if !reflect.DeepEqual(compilerListing.Files, []string{"a"}) || !reflect.DeepEqual(compilerListing.Directories, []string{"skip"}) {
     t.Fatalf("compiler listing changed: %#v", compilerListing)
   }

package/linthost/command_check_preserves_compiler_argument_cwd_test.go

@@ -55,7 +55,7 @@ func TestCommandCheckPreservesCompilerArgumentCwd(t *testing.T) {
       defer prog.close()
       normalized := func(value string) string { return filepath.ToSlash(filepath.Clean(value)) }
       options := prog.parsed.CompilerOptions()
-      if normalized(options.OutDir) != normalized(c.out) || normalized(options.RootDir) != normalized(b) || normalized(options.ConfigFilePath) != normalized(filepath.Join(b, "tsconfig.json")) {
+      if normalized(string(options.OutDir)) != normalized(c.out) || normalized(string(options.RootDir)) != normalized(b) || normalized(string(options.ConfigFilePath)) != normalized(filepath.Join(b, "tsconfig.json")) {
         t.Fatalf("wrong native options: out=%q root=%q config=%q", options.OutDir, options.RootDir, options.ConfigFilePath)
       }
       expectedRoot, err := os.Stat(b)
@@ -66,7 +66,7 @@ func TestCommandCheckPreservesCompilerArgumentCwd(t *testing.T) {
       if err != nil {
         t.Fatal(err)
       }
-      if prog.cwd != b || normalized(prog.tsProgram.GetCurrentDirectory()) != normalized(b) || prog.findSourceFile(filepath.Join(b, "main.ts")) == nil || prog.findSourceFile(filepath.Join(a, "main.ts")) != nil || !os.SameFile(expectedRoot, physicalRoot) {
+      if prog.cwd != b || normalized(string(prog.tsProgram.GetCurrentDirectory())) != normalized(b) || prog.findSourceFile(filepath.Join(b, "main.ts")) == nil || prog.findSourceFile(filepath.Join(a, "main.ts")) != nil || !os.SameFile(expectedRoot, physicalRoot) {
         t.Fatalf("compiler argument base replaced Program/rule identity: cwd=%q TypeScriptCwd=%q physicalRoot=%q expectedB=%q Bsource=%t Asource=%t", prog.cwd, prog.tsProgram.GetCurrentDirectory(), prog.identity.PhysicalProjectRoot, b, prog.findSourceFile(filepath.Join(b, "main.ts")) != nil, prog.findSourceFile(filepath.Join(a, "main.ts")) != nil)
       }
     })

package/linthost/comment_scan_handles_malformed_parser_recovery_test.go

@@ -6,6 +6,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 )
 
 // TestCommentScanHandlesMalformedParserRecovery verifies incomplete source is
@@ -27,7 +28,7 @@ import (
 func TestCommentScanHandlesMalformedParserRecovery(t *testing.T) {
   cases := []struct {
     name     string
-    fileName string
+    fileName shimtspath.RootedFilePath
     kind     shimcore.ScriptKind
     source   string
     comments []string

package/linthost/comment_scan_uses_parser_lexical_ranges_across_source_modes_test.go

@@ -9,6 +9,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 )
 
 // TestCommentScanUsesParserLexicalRangesAcrossSourceModes verifies exact,
@@ -58,7 +59,7 @@ func TestCommentScanUsesParserLexicalRangesAcrossSourceModes(t *testing.T) {
 
   cases := []struct {
     name     string
-    fileName string
+    fileName shimtspath.RootedFilePath
     kind     shimcore.ScriptKind
     source   string
     comments []string

package/linthost/compile.go

@@ -233,17 +233,14 @@ func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
   }
 
   var captured string
-  capture := func(name, text string, _ *shimcompiler.WriteFileData) error {
-    if !isJavaScriptOutput(name) {
+  capture := func(name shimtspath.RootedFilePath, text string, _ *shimcompiler.WriteFileData) error {
+    if !isJavaScriptOutput(string(name)) {
       return nil
     }
     captured = text
     return nil
   }
-  result := prog.tsProgram.Emit(context.Background(), shimcompiler.EmitOptions{
-    TargetSourceFile: target,
-    WriteFile:        shimcompiler.WriteFile(capture),
-  })
+  result := prog.tsProgram.Emit(context.Background(), shimcompiler.TargetedEmitOptions(target, shimcompiler.WriteFile(capture)))
   if result == nil {
     fmt.Fprintln(stderr, "@ttsc/lint transform: Emit returned nil")
     return 3
@@ -512,8 +509,8 @@ func runProject(opts *subcommandOpts) (code int) {
   }
 
   result := prog.tsProgram.Emit(context.Background(), shimcompiler.EmitOptions{
-    WriteFile: shimcompiler.WriteFile(func(fileName, text string, data *shimcompiler.WriteFileData) error {
-      return defaultWriteFile(fileName, text)
+    WriteFile: shimcompiler.WriteFile(func(fileName shimtspath.RootedFilePath, text string, data *shimcompiler.WriteFileData) error {
+      return defaultWriteFile(string(fileName), text)
     }),
   })
   if result == nil {

package/linthost/config.go

@@ -3959,8 +3959,10 @@ func fileURL(location string) string {
   if volume != "" {
     volumePath := filepath.ToSlash(volume)
     rest := strings.TrimPrefix(filepath.ToSlash(location[len(volume):]), "/")
-    if strings.HasPrefix(volumePath, "//?/UNC") {
-      return uncFileURL(rest)
+    if unc, ok := strings.CutPrefix(volumePath, "//?/UNC"); ok {
+      // Go 1.26 reports `\\?\UNC` as the volume and Go 1.27 reports
+      // `\\?\UNC\server\share`; the server and share follow the prefix either way.
+      return uncFileURL(strings.TrimPrefix(unc+"/"+rest, "/"))
     }
     if strings.HasPrefix(volumePath, "//?/") {
       pathname := "/" + strings.TrimPrefix(volumePath, "//?/")

package/linthost/config_loader_sources_escape_every_literal_percent_test.go

@@ -7,6 +7,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
 )
 
 // TestConfigLoaderSourcesEscapeEveryLiteralPercent verifies generated loader syntax
@@ -67,7 +68,7 @@ func TestConfigLoaderSourcesEscapeEveryLiteralPercent(t *testing.T) {
       )
     }
     parsed := shimparser.ParseSourceFile(
-      shimast.SourceFileParseOptions{FileName: "/virtual/" + generated.name + map[shimcore.ScriptKind]string{shimcore.ScriptKindJS: ".js", shimcore.ScriptKindTS: ".ts"}[generated.kind]},
+      shimast.SourceFileParseOptions{FileName: shimtspath.RootedFilePathFromAbsolute("/virtual/" + generated.name + map[shimcore.ScriptKind]string{shimcore.ScriptKindJS: ".js", shimcore.ScriptKindTS: ".ts"}[generated.kind])},
       generated.source,
       generated.kind,
     )

package/linthost/contributor_diagnostic_ranges_are_bounded_test.go

@@ -31,12 +31,12 @@ func TestContributorDiagnosticRangesAreBounded(t *testing.T) {
   }
   contributor := &boundedDiagnosticRangeContributor{
     spans: map[string][2]int{
-      files[0].FileName(): {-7, 5},
-      files[1].FileName(): {8, 3},
-      files[2].FileName(): {999, 1200},
-      files[3].FileName(): {len(files[3].Text()), len(files[3].Text())},
-      files[4].FileName(): {-4, 12},
-      files[5].FileName(): {6, 11},
+      string(files[0].FileName()): {-7, 5},
+      string(files[1].FileName()): {8, 3},
+      string(files[2].FileName()): {999, 1200},
+      string(files[3].FileName()): {len(files[3].Text()), len(files[3].Text())},
+      string(files[4].FileName()): {-4, 12},
+      string(files[5].FileName()): {6, 11},
     },
   }
   metadata, err := inspectContributor(contributor)
@@ -56,23 +56,23 @@ func TestContributorDiagnosticRangesAreBounded(t *testing.T) {
     t.Fatalf("findings = %d, want %d: %+v", got, want, findings)
   }
   expected := map[string][2]int{
-    files[0].FileName(): {0, 5},
-    files[1].FileName(): {8, 9},
-    files[2].FileName(): {len(files[2].Text()), len(files[2].Text())},
-    files[3].FileName(): {len(files[3].Text()), len(files[3].Text())},
-    files[4].FileName(): {0, 0},
-    files[5].FileName(): {6, 11},
+    string(files[0].FileName()): {0, 5},
+    string(files[1].FileName()): {8, 9},
+    string(files[2].FileName()): {len(files[2].Text()), len(files[2].Text())},
+    string(files[3].FileName()): {len(files[3].Text()), len(files[3].Text())},
+    string(files[4].FileName()): {0, 0},
+    string(files[5].FileName()): {6, 11},
   }
   seen := map[string]bool{}
   for _, finding := range findings {
-    want, ok := expected[finding.File.FileName()]
+    want, ok := expected[string(finding.File.FileName())]
     if !ok {
       t.Fatalf("unexpected finding file: %+v", finding)
     }
-    if seen[finding.File.FileName()] || finding.Message != "explicit contributor range" {
+    if seen[string(finding.File.FileName())] || finding.Message != "explicit contributor range" {
       t.Fatalf("duplicate file or lost contributor message: %+v", finding)
     }
-    seen[finding.File.FileName()] = true
+    seen[string(finding.File.FileName())] = true
     if finding.Pos != want[0] || finding.End != want[1] {
       t.Fatalf("range for %s = [%d,%d), want [%d,%d)",
         finding.File.FileName(), finding.Pos, finding.End, want[0], want[1])
@@ -86,8 +86,8 @@ func TestContributorDiagnosticRangesAreBounded(t *testing.T) {
 
     diagnostic := shimdw.NewLintDiagnostic(
       finding.File,
-      contributor.spans[finding.File.FileName()][0],
-      contributor.spans[finding.File.FileName()][1],
+      contributor.spans[string(finding.File.FileName())][0],
+      contributor.spans[string(finding.File.FileName())][1],
       9501,
       shimdw.LintCategoryError,
       "bounded contributor diagnostic",
@@ -118,8 +118,8 @@ func (*boundedDiagnosticRangeContributor) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindSourceFile}
 }
 func (r *boundedDiagnosticRangeContributor) Check(ctx *publicrule.Context, _ *shimast.Node) {
-  span := r.spans[ctx.File.FileName()]
-  if ctx.File.FileName() == r.fixFile {
+  span := r.spans[string(ctx.File.FileName())]
+  if string(ctx.File.FileName()) == r.fixFile {
     ctx.ReportRangeFix(span[0], span[1], "explicit contributor range", publicrule.TextEdit{
       Pos:  0,
       End:  5,

package/linthost/contributor_range_fix_bounds_diagnostic_independently_from_edit_test.go

@@ -20,8 +20,8 @@ import (
 func TestContributorRangeFixBoundsDiagnosticIndependentlyFromEdit(t *testing.T) {
   file := parseTSFile(t, "/virtual/range-fix.ts", "const value = 1;\n")
   contributor := &boundedDiagnosticRangeContributor{
-    spans:   map[string][2]int{file.FileName(): {999, -5}},
-    fixFile: file.FileName(),
+    spans:   map[string][2]int{string(file.FileName()): {999, -5}},
+    fixFile: string(file.FileName()),
   }
   metadata, err := inspectContributor(contributor)
   if err != nil {

package/linthost/contributor_report_related_reaches_finding_test.go

@@ -72,7 +72,7 @@ func TestContributorReportRelatedReachesFinding(t *testing.T) {
   if entry.Message != "defined over here" {
     t.Fatalf("render lost the message: %q", entry.Message)
   }
-  if want := fileURL(file.FileName()); entry.Location.URI != want {
+  if want := fileURL(string(file.FileName())); entry.Location.URI != want {
     t.Fatalf("related location must carry the finding's own file URI: want %q got %q", want, entry.Location.URI)
   }
   if entry.Location.Range.Start == entry.Location.Range.End {

package/linthost/engine.go

@@ -1368,7 +1368,7 @@ func (e *Engine) runFile(
 ) []*Finding {
   var collected []*Finding
   collect := func(f *Finding) { collected = append(collected, f) }
-  resolved := e.config.ResolveRules(file.FileName())
+  resolved := e.config.ResolveRules(string(file.FileName()))
   if resolved.Ignored {
     return collected
   }

package/linthost/engine_quarantines_panicking_rule_per_file_test.go

@@ -75,10 +75,10 @@ delta;
 
   for _, file := range []*shimast.SourceFile{first, second} {
     name := file.FileName()
-    if got, want := bomb.checks[name], 1; got != want {
+    if got, want := bomb.checks[string(name)], 1; got != want {
       t.Fatalf("panicking rule checks for %s = %d, want %d", name, got, want)
     }
-    if got, want := sibling.checks[name], 6; got != want {
+    if got, want := sibling.checks[string(name)], 6; got != want {
       t.Fatalf("sibling rule checks for %s = %d, want %d", name, got, want)
     }
   }
@@ -93,7 +93,7 @@ func (*fileQuarantinePanickingRule) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindIdentifier, shimast.KindNumericLiteral}
 }
 func (r *fileQuarantinePanickingRule) Check(ctx *Context, _ *shimast.Node) {
-  r.checks[ctx.File.FileName()]++
+  r.checks[string(ctx.File.FileName())]++
   panic("synthetic repeated panic")
 }
 
@@ -106,5 +106,5 @@ func (*fileQuarantineSiblingRule) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindIdentifier, shimast.KindNumericLiteral}
 }
 func (r *fileQuarantineSiblingRule) Check(ctx *Context, _ *shimast.Node) {
-  r.checks[ctx.File.FileName()]++
+  r.checks[string(ctx.File.FileName())]++
 }

package/linthost/engine_run_parallel_matches_serial_finding_set_test.go

@@ -77,7 +77,7 @@ func parallelFindingFingerprint(findings []*Finding) string {
   for _, f := range findings {
     name := ""
     if f.File != nil {
-      name = f.File.FileName()
+      name = string(f.File.FileName())
     }
     rows = append(rows, name+"|"+f.Rule+"|"+strconv.Itoa(f.Pos))
   }

package/linthost/fix.go

@@ -205,7 +205,7 @@ func applyFindingFixes(cwd string, findings []*Finding) (int, error) {
     if finding == nil || finding.File == nil || len(finding.Fix) == 0 {
       continue
     }
-    path := finding.File.FileName()
+    path := string(finding.File.FileName())
     if path == "" {
       continue
     }

package/linthost/helpers_test.go

@@ -19,6 +19,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"
 )
 
 var ruleExpectationPattern = regexp.MustCompile(`//\s*expect:\s*([@\w/-]+)\s+(error|warn)\s*$`)
@@ -61,9 +62,9 @@ func parseTS(t *testing.T, source string) *shimast.SourceFile {
 func parseTSFile(t *testing.T, fileName, source string) *shimast.SourceFile {
   t.Helper()
   opts := shimast.SourceFileParseOptions{
-    // The tsgo parser asserts on normalized absolute paths; Windows
-    // t.TempDir() callers would otherwise panic it with backslashes.
-    FileName: filepath.ToSlash(fileName),
+    // RootedFilePathFromAbsolute normalizes separators, so Windows t.TempDir()
+    // callers hand the parser the same rooted spelling as POSIX ones.
+    FileName: shimtspath.RootedFilePathFromAbsolute(fileName),
   }
   file := shimparser.ParseSourceFile(opts, source, shimcore.ScriptKindTS)
   if file == nil {
@@ -84,7 +85,7 @@ func parseTSXFile(t *testing.T, fileName, source string) *shimast.SourceFile {
   t.Helper()
   opts := shimast.SourceFileParseOptions{
     // Same normalization as parseTSFile — see the comment there.
-    FileName: filepath.ToSlash(fileName),
+    FileName: shimtspath.RootedFilePathFromAbsolute(fileName),
   }
   file := shimparser.ParseSourceFile(opts, source, shimcore.ScriptKindTSX)
   if file == nil {