ttsc 0.21.0 → 0.23.0

package/internal/lspserver/lsp_project_diagnostics_resident_unsupported_falls_back_test.go

@@ -0,0 +1,123 @@
+package lspserver
+
+import (
+  "bytes"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "runtime"
+  "strings"
+  "testing"
+)
+
+// TestLSPProjectDiagnosticsResidentUnsupportedFallsBack verifies a staged
+// sidecar can serve its advertised direct command through an older daemon.
+//
+// `lsp-serve` and its accepted request verbs can ship at different times. Once
+// a resident answers another verb, rejecting `lsp-project-diagnostics` is not a
+// transport failure and used to suppress the working one-shot command.
+//
+//  1. Build a sidecar whose daemon rejects only project diagnostics.
+//  2. Advertise the direct project-diagnostic capability.
+//  3. Request a publication and assert the one-shot command answers it.
+//  4. Assert both resident rejection and direct fallback occurred once.
+func TestLSPProjectDiagnosticsResidentUnsupportedFallsBack(t *testing.T) {
+  dir := t.TempDir()
+  sidecarSource := filepath.Join(dir, "sidecar.go")
+  if err := os.WriteFile(
+    sidecarSource,
+    []byte(projectDiagnosticsFallbackSidecarSource),
+    0644,
+  ); err != nil {
+    t.Fatal(err)
+  }
+  binary := filepath.Join(dir, "sidecar")
+  if runtime.GOOS == "windows" {
+    binary += ".exe"
+  }
+  build := exec.Command("go", "build", "-o", binary, sidecarSource)
+  if output, err := build.CombinedOutput(); err != nil {
+    t.Fatalf("go build sidecar failed: %v\n%s", err, output)
+  }
+  logPath := filepath.Join(dir, "calls.log")
+  t.Setenv("TTSC_PROJECT_DIAGNOSTICS_FALLBACK_LOG", logPath)
+  plugin := NativeLSPPluginEntry{
+    Binary:             binary,
+    Name:               "@ttsc/staged",
+    ProjectDiagnostics: true,
+  }
+  source := &NativePluginSource{
+    cwd:         dir,
+    err:         &bytes.Buffer{},
+    plugins:     []NativeLSPPluginEntry{plugin},
+    pluginsJSON: "[]",
+    tsconfig:    filepath.Join(dir, "tsconfig.json"),
+  }
+  t.Cleanup(source.shutdownResidents)
+
+  got := source.ProjectDiagnostics()
+
+  if got == nil || got.URI != "file:///project/tsconfig.json" ||
+    len(got.Diagnostics) != 1 ||
+    got.Diagnostics[0].Code != "direct" {
+    t.Fatalf("direct fallback publication = %#v", got)
+  }
+  calls, err := os.ReadFile(logPath)
+  if err != nil {
+    t.Fatal(err)
+  }
+  log := string(calls)
+  if strings.Count(log, "resident lsp-project-diagnostics") != 1 {
+    t.Fatalf("resident attempt count is wrong:\n%s", log)
+  }
+  if strings.Count(log, "direct lsp-project-diagnostics") != 1 {
+    t.Fatalf("direct fallback count is wrong:\n%s", log)
+  }
+}
+
+const projectDiagnosticsFallbackSidecarSource = `package main
+
+import (
+  "bufio"
+  "encoding/json"
+  "fmt"
+  "os"
+)
+
+type request struct {
+  Verb string ` + "`json:\"verb\"`" + `
+}
+
+func logCall(message string) {
+  path := os.Getenv("TTSC_PROJECT_DIAGNOSTICS_FALLBACK_LOG")
+  file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+  if err == nil {
+    _, _ = fmt.Fprintln(file, message)
+    _ = file.Close()
+  }
+}
+
+func main() {
+  if len(os.Args) < 2 {
+    os.Exit(2)
+  }
+  if os.Args[1] == "lsp-serve" {
+    scanner := bufio.NewScanner(os.Stdin)
+    for scanner.Scan() {
+      var req request
+      if json.Unmarshal(scanner.Bytes(), &req) != nil {
+        os.Exit(2)
+      }
+      logCall("resident " + req.Verb)
+      fmt.Println(` + "`" + `{"result":null,"code":2}` + "`" + `)
+    }
+    return
+  }
+  if os.Args[1] == "lsp-project-diagnostics" {
+    logCall("direct lsp-project-diagnostics")
+    fmt.Println(` + "`" + `{"uri":"file:///project/tsconfig.json","diagnostics":[{"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":0}},"code":"direct","message":"direct"}]}` + "`" + `)
+    return
+  }
+  os.Exit(2)
+}
+`

package/internal/lspserver/lsp_project_diagnostics_resume_preserves_generation_test.go

@@ -0,0 +1,52 @@
+package lspserver
+
+import "testing"
+
+type projectDiagnosticsResumeSource struct {
+  NullPluginSource
+}
+
+func (projectDiagnosticsResumeSource) ProjectDiagnostics() *LSPProjectDiagnostics {
+  return nil
+}
+
+// TestResumePendingProjectDiagnosticRefreshDoesNotReviveCompletedWork verifies
+// a save or close advances and rearms pending work atomically, while a refresh
+// completed before that transition remains completed.
+func TestResumePendingProjectDiagnosticRefreshDoesNotReviveCompletedWork(
+  t *testing.T,
+) {
+  proxy := NewProxy(ProxyOptions{
+    Source: projectDiagnosticsResumeSource{},
+  })
+  defer proxy.stopProjectDiagnosticRefresh()
+
+  proxy.scheduleProjectDiagnosticRefresh(projectDiagnosticOwnerScope{all: true})
+  proxy.diagnosticsMu.Lock()
+  before := proxy.projectDiagnosticGeneration
+  proxy.diagnosticsMu.Unlock()
+
+  proxy.resumePendingProjectDiagnosticRefresh()
+
+  proxy.diagnosticsMu.Lock()
+  after := proxy.projectDiagnosticGeneration
+  proxy.diagnosticsMu.Unlock()
+  if after != before+1 {
+    t.Fatalf("resume advanced generation from %d to %d", before, after)
+  }
+  proxy.projectRefreshMu.Lock()
+  pending := proxy.projectDiagnosticRefreshPending
+  generation := proxy.pendingProjectDiagnosticGeneration
+  proxy.projectRefreshMu.Unlock()
+  if !pending {
+    t.Fatal("resume cleared the pending refresh")
+  }
+  proxy.completePendingProjectDiagnosticRefresh(generation)
+  proxy.resumePendingProjectDiagnosticRefresh()
+  proxy.diagnosticsMu.Lock()
+  final := proxy.projectDiagnosticGeneration
+  proxy.diagnosticsMu.Unlock()
+  if final != after {
+    t.Fatalf("completed refresh was revived at generation %d", final)
+  }
+}

package/internal/lspserver/lsp_project_diagnostics_translates_relative_client_project_test.go

@@ -0,0 +1,90 @@
+package lspserver
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestLSPProjectDiagnosticsTranslatesRelativeClientProject verifies a project
+// URI is restated in the client's spelling however the client named it.
+//
+// The editor is not required to pass an absolute `--tsconfig`; naming the
+// project relative to the working directory it also passed is the ordinary
+// spelling, and every ttsc CLI accepts it. The translator, however, needs an
+// absolute path both to compare against the producer's URI and to build a URI
+// from, so a relative spelling used to end the translation and let the sidecar's
+// own spelling reach the editor unchanged — the precise failure this whole
+// translation exists to prevent, surviving in the common case.
+//
+// A client that named no directory either is not a case to decline: this host
+// was started from that directory and inherited it, so its own working
+// directory is the same anchor reached another way.
+//
+//  1. Resolve a relative project against the directory the client named.
+//  2. Resolve one against the directory the host inherited.
+//  3. Leave an absolute one exactly as the previous behavior did.
+func TestLSPProjectDiagnosticsTranslatesRelativeClientProject(t *testing.T) {
+  root := t.TempDir()
+  if err := os.WriteFile(
+    filepath.Join(root, "tsconfig.json"),
+    []byte("{}"),
+    0o644,
+  ); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.Mkdir(filepath.Join(root, "src"), 0o755); err != nil {
+    t.Fatalf("make src: %v", err)
+  }
+
+  // Spelled through a directory and back out, so it addresses the same file the
+  // client does without being the same string.
+  detour := func(directory string) string {
+    return projectInputFileURI(
+      filepath.Join(directory, "src") +
+        string(os.PathSeparator) + ".." +
+        string(os.PathSeparator) + "tsconfig.json",
+    )
+  }
+  named := detour(root)
+  expected := projectInputFileURI(filepath.Join(root, "tsconfig.json"))
+  if named == expected {
+    t.Fatalf("the producer URI must differ from the client's to be a test")
+  }
+
+  source := &NativePluginSource{
+    clientTsconfig: "tsconfig.json",
+    clientCwd:      root,
+  }
+  if got := source.clientProjectURI(named); got != expected {
+    t.Fatalf("relative project not translated: got %q, want %q", got, expected)
+  }
+
+  working, err := os.Getwd()
+  if err != nil {
+    t.Fatalf("working directory: %v", err)
+  }
+  inherited := &NativePluginSource{clientTsconfig: "tsconfig.json"}
+  inheritedWant := projectInputFileURI(filepath.Join(working, "tsconfig.json"))
+  if got := inherited.clientProjectURI(detour(working)); got != inheritedWant {
+    t.Fatalf(
+      "inherited directory not used: got %q, want %q",
+      got,
+      inheritedWant,
+    )
+  }
+
+  absolute := &NativePluginSource{
+    clientTsconfig: filepath.Join(root, "tsconfig.json"),
+  }
+  if got := absolute.clientProjectURI(named); got != expected {
+    t.Fatalf("absolute project no longer translated: got %q, want %q", got, expected)
+  }
+
+  // Nothing to translate to, so the producer keeps its own spelling rather than
+  // being addressed at a project the client never named.
+  unnamed := &NativePluginSource{}
+  if got := unnamed.clientProjectURI(named); got != named {
+    t.Fatalf("unnamed project was rewritten: got %q, want %q", got, named)
+  }
+}

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_ownership_resolves_declared_spellings_test.go

@@ -0,0 +1,95 @@
+package lspserver
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// TestLSPProjectInputOwnershipResolvesDeclaredSpellings verifies a declaration
+// is matched against an event through one filesystem identity.
+//
+// The candidate always arrives from an editor URI and is resolved physically,
+// so comparing it against a declaration that was only cleaned lexically can
+// never match wherever the two spellings differ. A Windows short (8.3)
+// component, which the system temporary directory routinely carries, and a
+// symlinked ancestor such as macOS `/var` both produce exactly that, and the
+// contributor that declared the file then receives no refresh at all.
+//
+//  1. Declare an exact file and a glob through a directory alias.
+//  2. Ask for the owners of the same paths spelled physically.
+//  3. Assert the declaring producer owns both.
+//  4. Assert two adjacent paths one property away are owned by nobody.
+func TestLSPProjectInputOwnershipResolvesDeclaredSpellings(t *testing.T) {
+  physical := t.TempDir()
+  alias := filepath.Join(t.TempDir(), "project")
+  if err := os.Symlink(physical, alias); err != nil {
+    t.Skipf("filesystem cannot express a directory alias: %v", err)
+  }
+  for _, directory := range []string{
+    filepath.Join(physical, "docs"),
+    filepath.Join(physical, "api"),
+  } {
+    if err := os.MkdirAll(directory, 0o755); err != nil {
+      t.Fatal(err)
+    }
+  }
+  exact := filepath.Join(physical, "docs", "spec.md")
+  matched := filepath.Join(physical, "api", "openapi.json")
+  for _, location := range []string{exact, matched} {
+    if err := os.WriteFile(location, []byte("{}\n"), 0o644); err != nil {
+      t.Fatal(err)
+    }
+  }
+
+  plugin := NativeLSPPluginEntry{
+    Binary:             "ttsc-no-such-alias-sidecar",
+    Name:               "@ttsc/alias",
+    ProjectDiagnostics: true,
+    ProjectInputs:      true,
+  }
+  source := &NativePluginSource{plugins: []NativeLSPPluginEntry{plugin}}
+  source.storeProjectInputs(plugin, 1, LSPProjectInputSnapshot{
+    Root:  filepath.ToSlash(alias),
+    Files: []string{filepath.ToSlash(filepath.Join(alias, "docs", "spec.md"))},
+    Globs: []string{
+      filepath.ToSlash(filepath.Join(alias, "api", "**", "*.json")),
+    },
+  })
+
+  for _, owned := range []struct {
+    label    string
+    location string
+  }{
+    {label: "exact declaration", location: exact},
+    {label: "glob member", location: matched},
+  } {
+    owners := source.ProjectInputOwnersForURI(testFileURI(owned.location))
+    if len(owners) != 1 || owners[0] != pluginKey(plugin) {
+      t.Fatalf("%s owners = %#v", owned.label, owners)
+    }
+  }
+
+  // Resolving both sides collapses distinct spellings onto one physical path,
+  // so over-matching is the failure this lane can produce. Each negative sits
+  // one property away from an owned path: the same directory with another
+  // extension, and the same extension outside every declaration.
+  for _, unowned := range []struct {
+    label    string
+    location string
+  }{
+    {
+      label:    "a sibling the glob does not select",
+      location: filepath.Join(physical, "api", "openapi.txt"),
+    },
+    {
+      label:    "a path outside every declaration",
+      location: filepath.Join(physical, "docs", "other.json"),
+    },
+  } {
+    owners := source.ProjectInputOwnersForURI(testFileURI(unowned.location))
+    if len(owners) != 0 {
+      t.Fatalf("%s owners = %#v", unowned.label, owners)
+    }
+  }
+}

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