ttsc 0.22.0 → 0.24.0

package/internal/graph/dump_symlink_project_publishes_matching_base_test.go

@@ -0,0 +1,82 @@
+package graph
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestDumpSymlinkProjectPublishesMatchingBase verifies relative wire paths and
+// the published project coordinate share one canonical filesystem base.
+//
+// A raw symlink cwd combined with canonical source paths makes `../` siblings,
+// missing literal roots and a symlinked relative tsconfig resolve incorrectly
+// unless project publication and path mapping use the same physical root.
+//
+//  1. Select a real project directory through a symlink and add sibling inputs.
+//  2. Map an existing sibling, a missing child and a relative config symlink.
+//  3. Require stable coordinates and a canonical published project base.
+func TestDumpSymlinkProjectPublishesMatchingBase(t *testing.T) {
+  root := t.TempDir()
+  realRoot := filepath.Join(root, "real")
+  project := filepath.Join(realRoot, "pkg")
+  configDir := filepath.Join(realRoot, "config")
+  if err := os.MkdirAll(project, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.MkdirAll(configDir, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  shared := filepath.Join(realRoot, "shared.ts")
+  config := filepath.Join(configDir, "tsconfig.json")
+  if err := os.WriteFile(shared, []byte("export const shared = true;\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(config, []byte("{}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  alias := filepath.Join(root, "project-link")
+  if err := os.Symlink(project, alias); err != nil {
+    t.Skipf("host cannot create directory symlink: %v", err)
+  }
+  if err := os.Symlink(config, filepath.Join(project, "tsconfig.json")); err != nil {
+    t.Skipf("host cannot create file symlink: %v", err)
+  }
+
+  mapper := newDumpPathMapper(alias)
+  if wire := mapper.mapPath(shared); wire != "../shared.ts" {
+    t.Fatalf("sibling wire path = %q, want ../shared.ts", wire)
+  }
+  if wire := mapper.mapPath(filepath.Join(alias, "src", "new.ts")); wire != "src/new.ts" {
+    t.Fatalf("missing-root wire path = %q, want src/new.ts", wire)
+  }
+  if wire := mapper.mapPath("tsconfig.json"); wire != "../config/tsconfig.json" {
+    t.Fatalf("relative config wire path = %q, want ../config/tsconfig.json", wire)
+  }
+  dump, err := NewDump(&Graph{Nodes: map[string]*Node{}}, alias, "tsconfig.json", nil, nil, DumpOrigin{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  physicalProject, err := filepath.EvalSymlinks(alias)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if filepath.Clean(filepath.FromSlash(dump.Project)) != filepath.Clean(physicalProject) {
+    t.Fatalf("published project = %q, want %q", dump.Project, physicalProject)
+  }
+  resolvedSibling := filepath.Clean(filepath.Join(filepath.FromSlash(dump.Project), filepath.FromSlash("../shared.ts")))
+  resolvedSiblingInfo, err := os.Stat(resolvedSibling)
+  if err != nil {
+    t.Fatal(err)
+  }
+  sharedInfo, err := os.Stat(shared)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !os.SameFile(resolvedSiblingInfo, sharedInfo) {
+    t.Fatalf("published base resolves sibling to %q, want %q", resolvedSibling, shared)
+  }
+  if dump.Tsconfig != "../config/tsconfig.json" {
+    t.Fatalf("published tsconfig = %q, want ../config/tsconfig.json", dump.Tsconfig)
+  }
+}

package/internal/graph/edges.go

@@ -18,9 +18,15 @@ import (
 // it annotates, a literal value set on the type that admits it. Both need the
 // same checker and the same walk, so they are resolved here and written to the
 // node the build pass keyed.
-func (g *Graph) addEdges(prog *driver.Program) {
+func (g *Graph) addEdges(prog *driver.Program, selected map[string]bool, partial bool) {
   checker := prog.Checker
   for _, file := range prog.SourceFiles() {
+    if !IsWorkspaceSourceFile(file) {
+      continue
+    }
+    if partial && !selected[file.FileName()] {
+      continue
+    }
     g.markExports(checker, file)
     g.collectHeritage(checker, file)
     g.collectCalls(checker, file)
@@ -54,7 +60,8 @@ func (g *Graph) addEdgeAt(from, to string, kind EdgeKind, origin string, pos, en
     return
   }
   g.seen[key] = struct{}{}
-  g.Edges = append(g.Edges, &Edge{From: from, To: to, Kind: kind, Origin: origin, Pos: pos, End: end})
+  file := g.edgeEvidenceFiles[from]
+  g.Edges = append(g.Edges, &Edge{From: from, To: to, Kind: kind, Origin: origin, File: file, Pos: pos, End: end})
 }
 
 // collectHeritage adds a heritage edge for every base of every class and
@@ -320,7 +327,7 @@ func graphMemberNodeID(g *Graph, member *shimast.Node) string {
     return ""
   }
   id := nodeID(file.FileName(), name, kind)
-  stored, ok := g.Nodes[id]
+  stored, ok := g.lookupNode(id)
   if !ok {
     return ""
   }
@@ -576,8 +583,10 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
       }
     case shimast.KindBinaryExpression:
       if target := g.assignedFunctionTarget(checker, from, child); target != "" {
-        g.recordImplementation(target, child)
-        g.callsWithin(checker, target, child.AsBinaryExpression().Right)
+        file := g.recordImplementation(target, child)
+        g.withEdgeEvidenceFile(target, file, func() {
+          g.callsWithin(checker, target, child.AsBinaryExpression().Right)
+        })
       }
     case shimast.KindJsxSelfClosingElement:
       // `<Component />` is a use of the component; an intrinsic tag (`<div />`)
@@ -615,18 +624,45 @@ func (g *Graph) assignedFunctionTarget(checker *shimchecker.Checker, from string
   return to
 }
 
-func (g *Graph) recordImplementation(id string, assignment *shimast.Node) {
-  node := g.Nodes[id]
-  if node == nil || node.External || node.ImplementationFile != "" {
-    return
+func (g *Graph) recordImplementation(id string, assignment *shimast.Node) string {
+  node, ok := g.lookupNode(id)
+  if !ok || node.External {
+    return ""
   }
   file := shimast.GetSourceFileOfNode(assignment)
   if file == nil {
+    return ""
+  }
+  sources := g.ImplementationSources[id]
+  if sources == nil {
+    sources = map[string]bool{}
+    g.ImplementationSources[id] = sources
+  }
+  sources[file.FileName()] = true
+  current := g.Nodes[id]
+  if current != nil && current.ImplementationFile == "" {
+    current.ImplementationFile = file.FileName()
+    current.ImplementationPos = assignment.Pos()
+    current.ImplementationEnd = assignment.End()
+  }
+  return file.FileName()
+}
+
+func (g *Graph) withEdgeEvidenceFile(from, file string, visit func()) {
+  if file == "" {
+    visit()
     return
   }
-  node.ImplementationFile = file.FileName()
-  node.ImplementationPos = assignment.Pos()
-  node.ImplementationEnd = assignment.End()
+  previous, existed := g.edgeEvidenceFiles[from]
+  g.edgeEvidenceFiles[from] = file
+  defer func() {
+    if existed {
+      g.edgeEvidenceFiles[from] = previous
+    } else {
+      delete(g.edgeEvidenceFiles, from)
+    }
+  }()
+  visit()
 }
 
 func isInvokedAccess(access *shimast.Node) bool {
@@ -745,7 +781,13 @@ func (g *Graph) typeRefsWithin(checker *shimchecker.Checker, from string, node *
       }
     case shimast.KindBinaryExpression:
       if target := g.assignedFunctionTarget(checker, from, child); target != "" {
-        g.typeRefsWithin(checker, target, child.AsBinaryExpression().Right)
+        file := ""
+        if source := shimast.GetSourceFileOfNode(child); source != nil {
+          file = source.FileName()
+        }
+        g.withEdgeEvidenceFile(target, file, func() {
+          g.typeRefsWithin(checker, target, child.AsBinaryExpression().Right)
+        })
       }
     }
     g.typeRefsWithin(checker, from, child)
@@ -795,7 +837,7 @@ func (g *Graph) ensureTargetNode(target *Target) string {
       return ""
     }
     id := nodeID(target.File, name, NodeMethod)
-    if _, exists := g.Nodes[id]; exists {
+    if _, exists := g.lookupNode(id); exists {
       return id
     }
     return ""
@@ -805,7 +847,7 @@ func (g *Graph) ensureTargetNode(target *Target) string {
   }
   name := qualifiedName(target.Symbol)
   id := nodeID(target.File, name, kind)
-  if _, exists := g.Nodes[id]; exists {
+  if _, exists := g.lookupNode(id); exists {
     return id
   }
   if !target.External {
@@ -851,7 +893,7 @@ func (g *Graph) closureTargetID(target *Target) string {
       kind = NodeVariable
     }
     id := nodeID(target.File, name, kind)
-    if _, exists := g.Nodes[id]; exists {
+    if _, exists := g.lookupNode(id); exists {
       return id
     }
   }

package/internal/graph/exports.go

@@ -108,10 +108,17 @@ func (g *Graph) markExportedSymbol(symbol *shimast.Symbol) (string, bool) {
   if name == "" {
     return "", false
   }
-  node, ok := g.Nodes[nodeID(file.FileName(), name, kind)]
+  node, ok := g.lookupNode(nodeID(file.FileName(), name, kind))
   if !ok {
     return "", false
   }
-  node.Exported = true
+  g.ExportedTargets[node.ID] = true
+  // A complete build and an invalidation transaction that includes the
+  // declaration owner both hold a fresh node and may stamp it directly. Never
+  // mutate a base node: it belongs to the last committed generation until the
+  // caller has assembled and validated every replacement shard.
+  if current, exists := g.Nodes[node.ID]; exists {
+    current.Exported = true
+  }
   return node.ID, true
 }

package/internal/graph/graph.go

@@ -171,9 +171,11 @@ const (
 )
 
 // Edge is a directed, checker-resolved relationship from one node to another,
-// both referenced by Node.ID. Pos and End bound the source expression in the
-// From node's file that produced the edge. They are evidence, not identity; a
-// duplicate relationship keeps the first source-order span.
+// both referenced by Node.ID. File, Pos, and End bound the source expression
+// that produced the edge. File is empty when the From node names it and is set
+// only when an assigned implementation attributes an expression in another
+// file to the declaration node it implements. They are evidence, not identity;
+// a duplicate relationship keeps the first source-order span.
 type Edge struct {
   From string
   To   string
@@ -186,6 +188,7 @@ type Edge struct {
   // "jsx", or "tagged"; for EdgeHeritage it is "extends" or "implements";
   // for EdgeMemberRelation it is "implements" or "overrides".
   Origin string
+  File   string
   Pos    int
   End    int
 }
@@ -196,10 +199,10 @@ type Graph struct {
   Nodes map[string]*Node
   Edges []*Edge
   // Decorators holds the decorators written on the workspace's declarations,
-  // captured syntactically so the JSON dump can emit `decorates` edges and a
-  // consumer can interpret `@Controller`/`@Get` conventions without re-parsing
-  // source. It is dump-only metadata, separate from Edges so the existing
-  // checker-resolved relationships are untouched.
+  // captured syntactically so the JSON dump can attach raw facts to each target
+  // node and a consumer can interpret `@Controller`/`@Get` conventions without
+  // re-parsing source. It is dump-only metadata, separate from Edges so the
+  // existing checker-resolved relationships are untouched.
   Decorators []*Decorator
   // bodyNodes tracks whether a callable node's display span is the overload
   // implementation rather than an overload signature. It is build-only metadata
@@ -213,6 +216,43 @@ type Graph struct {
   // build: the edge pass visits the same node several times, and a resolution
   // cannot change while the program is fixed.
   resolved map[*shimast.Node]*Target
+
+  // edgeEvidenceFiles temporarily overrides a declaration node's source while
+  // an assigned implementation in another file is walked. Builds are
+  // single-threaded, and the helper that installs an override restores it
+  // before the traversal returns.
+  edgeEvidenceFiles map[string]string
+
+  // baseNodes is the immutable endpoint index of the preceding committed
+  // generation during a partial build. Nodes owned by selectedFiles are never
+  // read through it: a changed file may delete or re-key a declaration, so its
+  // old nodes must disappear before the new checker walk begins.
+  baseNodes     map[string]*Node
+  selectedFiles map[string]bool
+
+  // ExportedTargets records every declaration reached through a selected
+  // module's checker export table. A partial caller uses it to add re-exported
+  // owner files to the same invalidation transaction before publishing.
+  ExportedTargets map[string]bool
+
+  // ImplementationSources records every source that assigns a function body
+  // to a modeled declaration, including candidates after the first assignment
+  // that supplied the node's display span. A partial caller uses the complete
+  // set to rebuild a declaration owner and all competing assignments together.
+  ImplementationSources map[string]map[string]bool
+}
+
+// lookupNode returns a node from this build, then from the preceding committed
+// endpoint index when that node's file is not being replaced.
+func (g *Graph) lookupNode(id string) (*Node, bool) {
+  if node, ok := g.Nodes[id]; ok {
+    return node, true
+  }
+  node, ok := g.baseNodes[id]
+  if !ok || g.selectedFiles[node.File] {
+    return nil, false
+  }
+  return node, true
 }
 
 // edgeKey identifies an edge by its two ends and the wire kind it will surface

package/internal/graph/graph_kind_contracts_match_their_producers_test.go

@@ -0,0 +1,121 @@
+package graph
+
+import (
+  "os"
+  "path/filepath"
+  "regexp"
+  "sort"
+  "testing"
+)
+
+// TestGraphKindContractsMatchTheirProducers keeps the hand-authored TypeScript
+// unions exact: raw dump kinds equal the Go producer, general kinds add only the
+// TypeScript memory/trace synthesis, and modifiers equal the emitted flag table.
+//
+// 1. Read every published graph-kind and modifier union.
+// 2. Derive raw dump values from the native constants and wire mapping.
+// 3. Apply the memory layer's module fold and synthetic kinds.
+// 4. Assert every published union equals its producer set exactly.
+func TestGraphKindContractsMatchTheirProducers(t *testing.T) {
+  structures := filepath.Join("..", "..", "..", "graph", "src", "structures")
+  rawNodes := stringUnion(t, filepath.Join(structures, "TtscGraphDumpNodeKind.ts"), "TtscGraphDumpNodeKind")
+  rawEdges := stringUnion(t, filepath.Join(structures, "TtscGraphDumpEdgeKind.ts"), "TtscGraphDumpEdgeKind")
+  nodes := stringUnion(t, filepath.Join(structures, "TtscGraphNodeKind.ts"), "TtscGraphNodeKind")
+  edges := stringUnion(t, filepath.Join(structures, "TtscGraphEdgeKind.ts"), "TtscGraphEdgeKind")
+  modifiers := stringUnion(t, filepath.Join(structures, "TtscGraphNodeModifier.ts"), "TtscGraphNodeModifier")
+
+  source, err := os.ReadFile("graph.go")
+  if err != nil {
+    t.Fatalf("read graph.go: %v", err)
+  }
+  nodeConstants := sourceConstants(t, source, `(?m)^\s*Node[A-Za-z0-9_]*\s+NodeKind\s*=\s*"([^"]+)"`)
+  edgeConstants := sourceConstants(t, source, `(?m)^\s*Edge[A-Za-z0-9_]*\s+EdgeKind\s*=\s*"([^"]+)"`)
+
+  assertStringSet(t, "raw dump node kinds", rawNodes, nodeConstants)
+  assertStringSet(t, "raw dump edge kinds", rawEdges, producedWireEdgeKinds(edgeConstants))
+  memoryNodeKinds := withoutString(nodeConstants, "module")
+  assertStringSet(t, "general graph node kinds", nodes, append(memoryNodeKinds, "file", "property"))
+  assertStringSet(t, "general graph edge kinds", edges, append(append([]string{}, producedWireEdgeKinds(edgeConstants)...), "contains", "dispatches"))
+
+  emittedModifiers := make([]string, 0, len(modifierFlagStrings))
+  for _, modifier := range modifierFlagStrings {
+    emittedModifiers = append(emittedModifiers, modifier.text)
+  }
+  assertStringSet(t, "graph node modifiers", modifiers, emittedModifiers)
+}
+
+func withoutString(values []string, excluded string) []string {
+  out := make([]string, 0, len(values))
+  for _, value := range values {
+    if value != excluded {
+      out = append(out, value)
+    }
+  }
+  return out
+}
+
+func stringUnion(t *testing.T, path, name string) []string {
+  t.Helper()
+  source, err := os.ReadFile(path)
+  if err != nil {
+    t.Fatalf("read %s: %v", path, err)
+  }
+  declaration := regexp.MustCompile(`(?s)export type ` + regexp.QuoteMeta(name) + `\s*=\s*(.*?);`).FindSubmatch(source)
+  if declaration == nil {
+    t.Fatalf("find exported union %s in %s", name, path)
+  }
+  return sourceConstants(t, declaration[1], `"([^"]+)"`)
+}
+
+func sourceConstants(t *testing.T, source []byte, pattern string) []string {
+  t.Helper()
+  matches := regexp.MustCompile(pattern).FindAllSubmatch(source, -1)
+  if len(matches) == 0 {
+    t.Fatalf("no string constants matched %q", pattern)
+  }
+  values := make([]string, 0, len(matches))
+  for _, match := range matches {
+    values = append(values, string(match[1]))
+  }
+  return values
+}
+
+func producedWireEdgeKinds(constants []string) []string {
+  values := map[string]bool{}
+  for _, constant := range constants {
+    kind := EdgeKind(constant)
+    origins := []string{""}
+    switch kind {
+    case EdgeValueCall:
+      origins = []string{"call", "new", "jsx", "tagged"}
+    case EdgeHeritage:
+      origins = []string{"extends", "implements"}
+    case EdgeMemberRelation:
+      origins = []string{"implements", "overrides"}
+    }
+    for _, origin := range origins {
+      values[wireEdgeKind(kind, origin)] = true
+    }
+  }
+  out := make([]string, 0, len(values))
+  for value := range values {
+    out = append(out, value)
+  }
+  return out
+}
+
+func assertStringSet(t *testing.T, name string, got, want []string) {
+  t.Helper()
+  got = append([]string{}, got...)
+  want = append([]string{}, want...)
+  sort.Strings(got)
+  sort.Strings(want)
+  if len(got) != len(want) {
+    t.Fatalf("%s = %v, want %v", name, got, want)
+  }
+  for i := range got {
+    if got[i] != want[i] {
+      t.Fatalf("%s = %v, want %v", name, got, want)
+    }
+  }
+}

package/internal/graph/node_modifiers_emit_union_strings_test.go

@@ -87,7 +87,7 @@ export const enum Mode {
   union := map[string]bool{
     "export": true, "default": true, "declare": true, "abstract": true,
     "static": true, "readonly": true, "async": true, "const": true,
-    "public": true, "private": true, "protected": true, "optional": true,
+    "public": true, "private": true, "protected": true,
   }
   for _, n := range dump.Nodes {
     for _, m := range n.Modifiers {

package/internal/graph/provenance.go

@@ -5,6 +5,7 @@ import (
   "encoding/hex"
   "sort"
 
+  shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcore "github.com/microsoft/typescript-go/shim/core"
 
   "github.com/samchon/ttsc/packages/ttsc/driver"
@@ -273,7 +274,16 @@ func NewProvenance(
 // every file the graph would otherwise only have bound. Callers that do not
 // publish diagnostics should not call it.
 func NewDiagnostics(prog *driver.Program) []Diagnostic {
-  raw := prog.Diagnostics()
+  return newDiagnostics(prog.Diagnostics())
+}
+
+// NewDiagnosticsForFiles projects compiler findings for one invalidated source
+// closure without forcing semantic diagnostics for every unchanged file.
+func NewDiagnosticsForFiles(prog *driver.Program, files []*shimast.SourceFile) []Diagnostic {
+  return newDiagnostics(prog.DiagnosticsForFiles(files))
+}
+
+func newDiagnostics(raw []driver.Diagnostic) []Diagnostic {
   out := make([]Diagnostic, 0, len(raw))
   for _, diagnostic := range raw {
     out = append(out, Diagnostic{

package/internal/graph/resolve.go

@@ -18,8 +18,6 @@
 package graph
 
 import (
-  "strings"
-
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
 )
@@ -80,8 +78,7 @@ func Resolve(checker *shimchecker.Checker, ref *shimast.Node) *Target {
     target.End = declaration.End()
     if file := shimast.GetSourceFileOfNode(declaration); file != nil {
       target.File = file.FileName()
-      target.External = file.IsDeclarationFile ||
-        strings.Contains(target.File, "/node_modules/")
+      target.External = !IsWorkspaceSourceFile(file)
     }
   }
   return target

package/internal/graph/source.go

@@ -0,0 +1,23 @@
+package graph
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// IsWorkspaceSourceFile reports whether file owns declarations and outgoing
+// facts in the project graph. Declaration files and sources physically resident
+// under node_modules are external boundary inputs even when the checker loads a
+// package's raw TypeScript entry for type checking.
+//
+// Symlinked workspace packages remain authored source: the checker resolves the
+// default preserveSymlinks=false path to their real workspace location before
+// this predicate sees it.
+func IsWorkspaceSourceFile(file *shimast.SourceFile) bool {
+  if file == nil || file.IsDeclarationFile {
+    return false
+  }
+  normalized := strings.ReplaceAll(file.FileName(), "\\", "/")
+  return !strings.Contains("/"+strings.TrimPrefix(normalized, "/"), "/node_modules/")
+}

package/internal/graph/wire_node_ids_share_alias_resolution_test.go

@@ -0,0 +1,29 @@
+package graph
+
+import "testing"
+
+// TestWireNodeIDsShareAliasResolution verifies the public resident shard
+// helper keeps declarations from one physical source distinct and stable.
+//
+// External declarations commonly share a package source file. Mapping the IDs
+// as one batch must preserve the shared source coordinate without collisions.
+//
+//  1. Build two declaration IDs owned by one physical dependency source.
+//  2. Map both IDs through the public batch helper.
+//  3. Require distinct IDs with the same portable source coordinate.
+func TestWireNodeIDsShareAliasResolution(t *testing.T) {
+  source := "C:/checkout/app/node_modules/pkg/index.d.ts"
+  first := nodeID(source, "First", NodeClass)
+  second := nodeID(source, "Second", NodeClass)
+  wire, err := WireNodeIDs("C:/checkout/app", []string{first, second})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if wire[first] == wire[second] {
+    t.Fatalf("wire IDs collide: %q", wire[first])
+  }
+  expectedSource := "node_modules/pkg/index.d.ts"
+  if nodeFile(wire[first]) != expectedSource || nodeFile(wire[second]) != expectedSource {
+    t.Fatalf("wire source coordinates = %q and %q, want %q", nodeFile(wire[first]), nodeFile(wire[second]), expectedSource)
+  }
+}

package/internal/lspserver/lsp_launcher_reload_directory_fingerprint_parity_windows_test.go

@@ -0,0 +1,94 @@
+//go:build windows
+
+package lspserver
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLauncherReloadDirectoryFingerprintMatchesGo verifies that the JavaScript
+// launcher and Go host serialize the same Windows physical directory identity.
+//
+// The launcher formerly retained a physical drive volume while Go lowercased
+// it, and the two sides also disagreed about case folding for a missing suffix.
+// A stable launcher snapshot was therefore rejected as stale during native
+// watcher registration.
+//
+//  1. Ask the built JavaScript launcher to fingerprint one existing directory
+//     and one missing descendant under an ordinary case-insensitive parent.
+//  2. Pass each launcher-produced digest through the real Go snapshot
+//     normalization path.
+//  3. Prove the Go currentness validator accepts both unchanged directories.
+func TestLauncherReloadDirectoryFingerprintMatchesGo(t *testing.T) {
+  root := t.TempDir()
+  existing := filepath.Join(root, "ExistingDirectory")
+  if err := os.Mkdir(existing, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  for _, directory := range []string{
+    existing,
+    filepath.Join(root, "MissingDirectory"),
+  } {
+    digest := launcherReloadDirectoryDigest(t, root, directory)
+    snapshot, err := normalizeLSPProjectInputSnapshot(
+      LSPProjectInputSnapshot{
+        Root:              root,
+        ReloadDirectories: []string{directory},
+        ReloadDirectoryDigests: map[string]string{
+          directory: digest,
+        },
+      },
+      root,
+    )
+    if err != nil {
+      t.Fatalf("normalize launcher fingerprint for %q: %v", directory, err)
+    }
+    if !projectInputReloadFingerprintsAreCurrent(snapshot) {
+      t.Fatalf("launcher fingerprint for %q began stale in Go", directory)
+    }
+  }
+}
+
+func launcherReloadDirectoryDigest(
+  t *testing.T,
+  root string,
+  directory string,
+) string {
+  t.Helper()
+  module, err := filepath.Abs(
+    filepath.Join("..", "..", "lib", "launcher", "internal", "runTtscserver.js"),
+  )
+  if err != nil {
+    t.Fatal(err)
+  }
+  script := `
+    import { pathToFileURL } from "node:url";
+    const launcher = await import(pathToFileURL(process.argv[1]).href);
+    const location = process.argv[2];
+    const snapshot = launcher.fingerprintInitialLSPProjectInputSnapshot({
+      files: [],
+      globs: [],
+      reloadDirectories: [location],
+      root: process.argv[3],
+    });
+    process.stdout.write(snapshot.reloadDirectoryDigests[location]);
+  `
+  command := exec.Command(
+    "node",
+    "--input-type=module",
+    "--eval",
+    script,
+    module,
+    directory,
+    root,
+  )
+  output, err := command.CombinedOutput()
+  if err != nil {
+    t.Fatalf("launcher fingerprint for %q: %v\n%s", directory, err, output)
+  }
+  return strings.TrimSpace(string(output))
+}

package/internal/lspserver/lsp_project_input_glob_path_other.go

@@ -0,0 +1,16 @@
+//go:build !windows
+
+package lspserver
+
+import "strings"
+
+func projectInputGlobMatchesCandidate(
+  pattern string,
+  candidate string,
+) bool {
+  return matchProjectInputGlob(
+    strings.Split(projectInputPathKey(realProjectInputPath(pattern)), "/"),
+    strings.Split(projectInputPathKey(realProjectInputPath(candidate)), "/"),
+    nil,
+  )
+}