ttsc 0.21.0 → 0.22.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_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)
+    }
+  }
+}