ttsc 0.22.0 → 0.23.0

package/go.mod

@@ -41,6 +41,7 @@ require (
 	github.com/microsoft/typescript-go/shim/vfs v0.0.0
 	github.com/microsoft/typescript-go/shim/vfs/cachedvfs v0.0.0
 	github.com/microsoft/typescript-go/shim/vfs/osvfs v0.0.0
+	golang.org/x/sys v0.43.0
 )
 
 require (
@@ -49,6 +50,5 @@ require (
 	github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157 // indirect
 	github.com/zeebo/xxh3 v1.1.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/sys v0.43.0 // indirect
 	golang.org/x/text v0.36.0 // indirect
 )

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,
+  )
+}

package/internal/lspserver/lsp_project_input_glob_path_windows.go

@@ -0,0 +1,36 @@
+//go:build windows
+
+package lspserver
+
+import (
+  "path/filepath"
+  "strings"
+)
+
+func projectInputGlobMatchesCandidate(
+  pattern string,
+  candidate string,
+) bool {
+  resolvedPattern := resolveWindowsProjectInputPath(pattern)
+  resolvedCandidate := resolveWindowsProjectInputPath(candidate)
+  if !resolvedPattern.found || !resolvedCandidate.found {
+    return false
+  }
+  patternVolume := strings.ToLower(
+    filepath.ToSlash(filepath.VolumeName(resolvedPattern.physical)),
+  )
+  candidateVolume := strings.ToLower(
+    filepath.ToSlash(filepath.VolumeName(resolvedCandidate.physical)),
+  )
+  if patternVolume != candidateVolume {
+    return false
+  }
+  patternSegments, _ := windowsProjectInputSegments(resolvedPattern)
+  candidateSegments, candidateSensitivities :=
+    windowsProjectInputSegments(resolvedCandidate)
+  return matchProjectInputGlob(
+    patternSegments,
+    candidateSegments,
+    candidateSensitivities,
+  )
+}

package/internal/lspserver/lsp_project_input_path_key_other.go

@@ -0,0 +1,17 @@
+//go:build !windows
+
+package lspserver
+
+import "path/filepath"
+
+func physicalProjectInputPath(location string) (string, error) {
+  return filepath.EvalSymlinks(location)
+}
+
+func projectInputPhysicalPathKey(location string) string {
+  return filepath.ToSlash(realProjectInputPath(location))
+}
+
+func projectInputPathKey(location string) string {
+  return filepath.ToSlash(filepath.Clean(filepath.FromSlash(location)))
+}

package/internal/lspserver/lsp_project_input_path_key_windows.go

@@ -0,0 +1,228 @@
+//go:build windows
+
+package lspserver
+
+import (
+  "path/filepath"
+  "strings"
+  "unsafe"
+
+  "golang.org/x/sys/windows"
+)
+
+type windowsProjectInputPath struct {
+  found    bool
+  missing  []string
+  physical string
+}
+
+// projectInputPathKey resolves existing spelling through the filesystem and
+// applies case folding to each segment according to the directory that owns
+// that name. Windows case semantics are per directory, not per volume or OS.
+func projectInputPathKey(location string) string {
+  normalized := filepath.Clean(projectInputFilesystemPath(location))
+  if !filepath.IsAbs(normalized) {
+    return strings.ToLower(filepath.ToSlash(normalized))
+  }
+  volume := filepath.VolumeName(normalized)
+  segments := splitWindowsProjectInputSegments(
+    strings.TrimPrefix(normalized, volume),
+  )
+  current := windowsProjectInputVolumeRoot(volume)
+  sensitive := false
+  for index, segment := range segments {
+    if currentSensitivity, ok :=
+      tryQueryProjectInputDirectoryCaseSensitivity(current); ok {
+      sensitive = currentSensitivity
+    }
+    if !sensitive {
+      segments[index] = strings.ToLower(segments[index])
+    }
+    current = filepath.Join(current, segment)
+  }
+  return windowsProjectInputKey(normalized, segments)
+}
+
+func resolveWindowsProjectInputPath(location string) windowsProjectInputPath {
+  normalized := filepath.Clean(projectInputFilesystemPath(location))
+  if !filepath.IsAbs(normalized) {
+    return windowsProjectInputPath{physical: normalized}
+  }
+  probe := normalized
+  missing := []string{}
+  for {
+    physical, err := physicalProjectInputPath(probe)
+    if err == nil {
+      return windowsProjectInputPath{
+        found:    true,
+        missing:  reverseWindowsProjectInputSegments(missing),
+        physical: filepath.Clean(physical),
+      }
+    }
+    parent := filepath.Dir(probe)
+    if parent == probe {
+      return windowsProjectInputPath{physical: normalized}
+    }
+    missing = append(missing, filepath.Base(probe))
+    probe = parent
+  }
+}
+
+func physicalProjectInputPath(location string) (string, error) {
+  pointer, err := windows.UTF16PtrFromString(location)
+  if err != nil {
+    return "", err
+  }
+  handle, err := windows.CreateFile(
+    pointer,
+    windows.FILE_READ_ATTRIBUTES,
+    windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE|windows.FILE_SHARE_DELETE,
+    nil,
+    windows.OPEN_EXISTING,
+    windows.FILE_FLAG_BACKUP_SEMANTICS,
+    0,
+  )
+  if err != nil {
+    return "", err
+  }
+  defer windows.CloseHandle(handle)
+
+  buffer := make([]uint16, windows.MAX_PATH)
+  for {
+    length, err := windows.GetFinalPathNameByHandle(
+      handle,
+      &buffer[0],
+      uint32(len(buffer)),
+      0,
+    )
+    if err != nil {
+      return "", err
+    }
+    if length < uint32(len(buffer)) {
+      return filepath.Clean(
+        projectInputFilesystemPath(
+          windows.UTF16ToString(buffer[:length]),
+        ),
+      ), nil
+    }
+    buffer = make([]uint16, length+1)
+  }
+}
+
+func projectInputPhysicalPathKey(location string) string {
+  resolved := resolveWindowsProjectInputPath(location)
+  volume := filepath.VolumeName(resolved.physical)
+  segments := splitWindowsProjectInputSegments(
+    strings.TrimPrefix(resolved.physical, volume),
+  )
+  if len(resolved.missing) != 0 {
+    missing := append([]string{}, resolved.missing...)
+    if !queryProjectInputDirectoryCaseSensitivity(resolved.physical) {
+      for index := range missing {
+        missing[index] = strings.ToLower(missing[index])
+      }
+    }
+    segments = append(segments, missing...)
+  }
+  prefix := filepath.ToSlash(volume)
+  if len(segments) == 0 {
+    return prefix + "/"
+  }
+  return prefix + "/" + strings.Join(segments, "/")
+}
+
+func windowsProjectInputSegments(
+  resolved windowsProjectInputPath,
+) ([]string, []bool) {
+  volume := filepath.VolumeName(resolved.physical)
+  existing := splitWindowsProjectInputSegments(
+    strings.TrimPrefix(resolved.physical, volume),
+  )
+  segments := append(append([]string{}, existing...), resolved.missing...)
+  sensitivities := make([]bool, 0, len(segments))
+  current := windowsProjectInputVolumeRoot(volume)
+  for _, segment := range existing {
+    sensitivities = append(
+      sensitivities,
+      queryProjectInputDirectoryCaseSensitivity(current),
+    )
+    current = filepath.Join(current, segment)
+  }
+  if len(resolved.missing) != 0 {
+    missingSensitivity := queryProjectInputDirectoryCaseSensitivity(
+      resolved.physical,
+    )
+    for range resolved.missing {
+      sensitivities = append(sensitivities, missingSensitivity)
+    }
+  }
+  return segments, sensitivities
+}
+
+func windowsProjectInputKey(location string, segments []string) string {
+  volume := filepath.VolumeName(location)
+  prefix := strings.ToLower(filepath.ToSlash(volume))
+  if len(segments) == 0 {
+    return prefix + "/"
+  }
+  return prefix + "/" + strings.Join(segments, "/")
+}
+
+func windowsProjectInputVolumeRoot(volume string) string {
+  if strings.HasSuffix(volume, `\`) || strings.HasSuffix(volume, "/") {
+    return volume
+  }
+  return volume + `\`
+}
+
+func splitWindowsProjectInputSegments(location string) []string {
+  return strings.FieldsFunc(location, func(character rune) bool {
+    return character == '/' || character == '\\'
+  })
+}
+
+func reverseWindowsProjectInputSegments(segments []string) []string {
+  reversed := make([]string, len(segments))
+  for index := range segments {
+    reversed[len(segments)-index-1] = segments[index]
+  }
+  return reversed
+}
+
+func queryProjectInputDirectoryCaseSensitivity(directory string) bool {
+  sensitive, _ := tryQueryProjectInputDirectoryCaseSensitivity(directory)
+  return sensitive
+}
+
+func tryQueryProjectInputDirectoryCaseSensitivity(
+  directory string,
+) (bool, bool) {
+  pointer, err := windows.UTF16PtrFromString(directory)
+  if err != nil {
+    return false, false
+  }
+  handle, err := windows.CreateFile(
+    pointer,
+    windows.FILE_READ_ATTRIBUTES,
+    windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE|windows.FILE_SHARE_DELETE,
+    nil,
+    windows.OPEN_EXISTING,
+    windows.FILE_FLAG_BACKUP_SEMANTICS,
+    0,
+  )
+  if err != nil {
+    return false, false
+  }
+  defer windows.CloseHandle(handle)
+
+  var flags uint32
+  if err := windows.GetFileInformationByHandleEx(
+    handle,
+    windows.FileCaseSensitiveInfo,
+    (*byte)(unsafe.Pointer(&flags)),
+    uint32(unsafe.Sizeof(flags)),
+  ); err != nil {
+    return false, false
+  }
+  return flags&windows.FILE_CS_FLAG_CASE_SENSITIVE_DIR != 0, true
+}