ttsc 0.20.1 → 0.22.0

package/internal/lspserver/lsp_project_diagnostics.go

@@ -0,0 +1,235 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+)
+
+// projectDiagnosticRecord is one producer's last successful project
+// publication. A failed refresh never updates the record, so another producer's
+// success cannot erase diagnostics that were still valid before the failure.
+type projectDiagnosticRecord struct {
+  generation  uint64
+  publication LSPProjectDiagnostics
+}
+
+type projectDiagnosticsRefreshResult struct {
+  publication *LSPProjectDiagnostics
+  refreshed   map[string]struct{}
+  complete    bool
+  selected    int
+}
+
+// ProjectDiagnostics evaluates project rules without requiring an open
+// document and returns the latest successful publication from every capable
+// sidecar.
+func (s *NativePluginSource) ProjectDiagnostics() *LSPProjectDiagnostics {
+  return s.ProjectDiagnosticsForOwners(nil).publication
+}
+
+// ProjectDiagnosticsForOwners refreshes only the diagnostics-capable producers
+// named by owners. A nil owner list preserves the legacy all-producer request;
+// an empty non-nil list is a successful no-op.
+func (s *NativePluginSource) ProjectDiagnosticsForOwners(
+  owners []string,
+) projectDiagnosticsRefreshResult {
+  if s == nil {
+    return projectDiagnosticsRefreshResult{}
+  }
+  selectedOwners := map[string]struct{}{}
+  if owners != nil {
+    for _, owner := range owners {
+      selectedOwners[owner] = struct{}{}
+    }
+  }
+  generation := s.projectDiagnosticsSequence.Add(1)
+  result := projectDiagnosticsRefreshResult{
+    complete:  true,
+    refreshed: map[string]struct{}{},
+  }
+  for _, plugin := range selectPluginTransports(
+    s.plugins,
+    func(plugin NativeLSPPluginEntry) bool {
+      return plugin.ProjectDiagnostics
+    },
+    s.projectContextJSON,
+  ) {
+    key := pluginKey(plugin, s.projectContextJSON)
+    if owners != nil {
+      if _, selected := selectedOwners[key]; !selected {
+        continue
+      }
+    }
+    result.selected++
+    body, err := s.run(plugin, serveVerbProjectDiagnostics)
+    if err != nil {
+      s.log("%v", err)
+      result.complete = false
+      continue
+    }
+    var publication *LSPProjectDiagnostics
+    if err := json.Unmarshal(body, &publication); err != nil {
+      s.log(
+        "ttscserver: %s lsp-project-diagnostics returned invalid JSON: %v",
+        pluginLabel(plugin),
+        err,
+      )
+      result.complete = false
+      continue
+    }
+    if publication == nil || publication.URI == "" {
+      result.complete = false
+      continue
+    }
+    s.storeProjectDiagnostics(plugin, generation, publication)
+    result.refreshed[key] = struct{}{}
+  }
+  result.publication = s.projectDiagnosticsSnapshot()
+  return result
+}
+
+// storeProjectDiagnostics replaces one producer's last-good publication. A
+// successful empty diagnostics array clears that producer while leaving every
+// other producer unchanged.
+func (s *NativePluginSource) storeProjectDiagnostics(
+  plugin NativeLSPPluginEntry,
+  generation uint64,
+  publication *LSPProjectDiagnostics,
+) {
+  if publication == nil || publication.URI == "" {
+    return
+  }
+  key := pluginKey(plugin, s.projectContextJSON)
+  copied := copyProjectDiagnostics(publication)
+  s.projectDiagnosticsMu.Lock()
+  defer s.projectDiagnosticsMu.Unlock()
+  if existing, ok := s.pluginProjectDiagnostics[key]; ok &&
+    generation < existing.generation {
+    return
+  }
+  if s.pluginProjectDiagnostics == nil {
+    s.pluginProjectDiagnostics = map[string]projectDiagnosticRecord{}
+  }
+  s.pluginProjectDiagnostics[key] = projectDiagnosticRecord{
+    generation:  generation,
+    publication: *copied,
+  }
+}
+
+// clientProjectURI restates a producer's project URI in the spelling the client
+// opened the project under.
+//
+// A sidecar is deliberately given the project's physical paths, because that is
+// what makes its compiler, its caches, and its own resolution agree with every
+// other consumer. The editor never saw those paths. It opened the project under
+// whatever spelling its workspace uses — through a symlink, a mapped drive, a
+// case that differs — and a publication addressed to any other spelling is
+// invisible to it no matter how correct the diagnostics inside are. So the one
+// place the two worlds meet translates back.
+func (s *NativePluginSource) clientProjectURI(uri string) string {
+  if s == nil || uri == "" {
+    return uri
+  }
+  client, key := s.clientProjectIdentity()
+  if client == "" {
+    return uri
+  }
+  location, ok := filePathFromURI(uri)
+  if !ok {
+    return uri
+  }
+  if projectInputPathKey(realProjectInputPath(location)) != key {
+    return uri
+  }
+  return projectInputFileURI(client)
+}
+
+// clientProjectIdentity is the project as the client named it, absolute, with
+// the key a producer's URI is compared against. Empty when the client named no
+// project at all, which is the one case where there is nothing to translate to.
+func (s *NativePluginSource) clientProjectIdentity() (string, string) {
+  s.clientProjectOnce.Do(func() {
+    client := projectInputFilesystemPath(strings.TrimSpace(s.clientTsconfig))
+    if client == "" {
+      return
+    }
+    if !filepath.IsAbs(client) {
+      // The client names its project relative to the directory it asked this
+      // host to work in. When it named none, the host was started from that
+      // directory and inherited it, so the process directory is not a guess
+      // here — it is the same answer by another route.
+      base := projectInputFilesystemPath(strings.TrimSpace(s.clientCwd))
+      if base == "" {
+        working, err := os.Getwd()
+        if err != nil {
+          return
+        }
+        base = working
+      }
+      absolute, err := filepath.Abs(base)
+      if err != nil {
+        return
+      }
+      client = filepath.Join(absolute, client)
+    }
+    if !filepath.IsAbs(client) {
+      return
+    }
+    s.clientProject = client
+    s.clientProjectKey = projectInputPathKey(realProjectInputPath(client))
+  })
+  return s.clientProject, s.clientProjectKey
+}
+
+// projectDiagnosticsSnapshot concatenates producer publications in manifest
+// order. A project has one config URI, so a producer that reports a different
+// URI is excluded and logged rather than replacing the other producers.
+func (s *NativePluginSource) projectDiagnosticsSnapshot() *LSPProjectDiagnostics {
+  s.projectDiagnosticsMu.RLock()
+  defer s.projectDiagnosticsMu.RUnlock()
+  var out *LSPProjectDiagnostics
+  for _, plugin := range selectPluginTransports(
+    s.plugins,
+    nil,
+    s.projectContextJSON,
+  ) {
+    key := pluginKey(plugin, s.projectContextJSON)
+    record, ok := s.pluginProjectDiagnostics[key]
+    if !ok {
+      continue
+    }
+    publication := record.publication
+    publication.URI = s.clientProjectURI(publication.URI)
+    if out == nil {
+      out = copyProjectDiagnostics(&publication)
+      continue
+    }
+    if out.URI != publication.URI {
+      s.log(
+        "ttscserver: %s lsp-project-diagnostics returned URI %q, want %q",
+        pluginLabel(plugin),
+        publication.URI,
+        out.URI,
+      )
+      continue
+    }
+    out.Diagnostics = append(out.Diagnostics, publication.Diagnostics...)
+  }
+  return out
+}
+
+func copyProjectDiagnostics(
+  publication *LSPProjectDiagnostics,
+) *LSPProjectDiagnostics {
+  if publication == nil {
+    return nil
+  }
+  copied := *publication
+  copied.Diagnostics = append(
+    []LSPDiagnostic(nil),
+    publication.Diagnostics...,
+  )
+  return &copied
+}

package/internal/lspserver/lsp_project_diagnostics_capability_is_independent_test.go

@@ -0,0 +1,67 @@
+package lspserver
+
+import (
+  "bytes"
+  "strings"
+  "testing"
+)
+
+// TestLSPProjectDiagnosticsCapabilityIsIndependent verifies the standalone
+// diagnostic command is not inferred from project-input topology support.
+//
+// A third-party sidecar may implement `project-inputs` without implementing
+// `lsp-project-diagnostics`, while a staged diagnostic sidecar may expose the
+// inverse combination. Probing either command under the other capability makes
+// strict sidecars fail an undocumented command.
+//
+//  1. Configure a topology-only plugin and a diagnostics-only plugin.
+//  2. Seed the diagnostics producer, then make its next refresh fail to launch.
+//  3. Assert only the explicitly capable producer was invoked.
+//  4. Assert its last-good publication remains available after the failure.
+func TestLSPProjectDiagnosticsCapabilityIsIndependent(t *testing.T) {
+  topologyOnly := NativeLSPPluginEntry{
+    Binary:        "ttsc-no-such-topology-only-sidecar",
+    Name:          "@ttsc/topology-only",
+    ProjectInputs: true,
+  }
+  diagnosticsOnly := NativeLSPPluginEntry{
+    Binary:             "ttsc-no-such-diagnostics-only-sidecar",
+    Name:               "@ttsc/diagnostics-only",
+    ProjectDiagnostics: true,
+  }
+  var log bytes.Buffer
+  source := &NativePluginSource{
+    err:     &log,
+    plugins: []NativeLSPPluginEntry{topologyOnly, diagnosticsOnly},
+  }
+  source.storeProjectDiagnostics(
+    diagnosticsOnly,
+    1,
+    &LSPProjectDiagnostics{
+      URI: "file:///project/tsconfig.json",
+      Diagnostics: []LSPDiagnostic{{
+        Code:    "last-good",
+        Message: "last-good",
+      }},
+    },
+  )
+
+  got := source.ProjectDiagnostics()
+
+  if strings.Contains(log.String(), topologyOnly.Name) {
+    t.Fatalf(
+      "projectInputs incorrectly enabled lsp-project-diagnostics:\n%s",
+      log.String(),
+    )
+  }
+  if !strings.Contains(log.String(), diagnosticsOnly.Name) {
+    t.Fatalf(
+      "projectDiagnostics did not enable its direct command:\n%s",
+      log.String(),
+    )
+  }
+  if got == nil || len(got.Diagnostics) != 1 ||
+    got.Diagnostics[0].Code != "last-good" {
+    t.Fatalf("failed capable producer lost its last-good publication: %#v", got)
+  }
+}

package/internal/lspserver/lsp_project_diagnostics_program_input_overlap_refreshes_all_producers_test.go

@@ -0,0 +1,78 @@
+package lspserver
+
+import (
+  "bytes"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLSPProjectDiagnosticsProgramInputOverlapRefreshesAllProducers verifies a
+// declared input that can also belong to the Program widens diagnostic scope.
+//
+// Only the first producer declares the path, but both project-rule producers
+// observe the shared Program. TypeScript and resolveJsonModule JSON edits must
+// therefore refresh both, while a path that can only be data keeps the
+// owner-scoped behavior pinned by
+// lsp_project_diagnostics_refreshes_only_input_owners_test.go.
+//
+//  1. Declare one shared-Program path for the first producer only.
+//  2. Resolve its owner scope and widen it as a watched Program input.
+//  3. Assert the scope became all-producer.
+//  4. Refresh and assert both producers were invoked.
+func TestLSPProjectDiagnosticsProgramInputOverlapRefreshesAllProducers(
+  t *testing.T,
+) {
+  for _, name := range []string{"shared.ts", "shared.json"} {
+    t.Run(name, func(t *testing.T) {
+      root := t.TempDir()
+      first := NativeLSPPluginEntry{
+        Binary:             "ttsc-no-such-first-program-sidecar",
+        Name:               "@ttsc/first-program",
+        ProjectDiagnostics: true,
+        ProjectInputs:      true,
+      }
+      second := NativeLSPPluginEntry{
+        Binary:             "ttsc-no-such-second-program-sidecar",
+        Name:               "@ttsc/second-program",
+        ProjectDiagnostics: true,
+        ProjectInputs:      true,
+      }
+      var log bytes.Buffer
+      source := &NativePluginSource{
+        err:     &log,
+        plugins: []NativeLSPPluginEntry{first, second},
+      }
+      input := filepath.Join(root, "src", name)
+      source.storeProjectInputs(first, 1, LSPProjectInputSnapshot{
+        Root:  filepath.ToSlash(root),
+        Files: []string{filepath.ToSlash(input)},
+      })
+      source.storeProjectInputs(second, 1, LSPProjectInputSnapshot{
+        Root: filepath.ToSlash(root),
+        Files: []string{
+          filepath.ToSlash(filepath.Join(root, "docs", "second.md")),
+        },
+      })
+      uri := testFileURI(input)
+      scope, matched := (&Proxy{source: source}).projectInputOwnerScope(uri)
+      if !matched || scope.all || len(scope.owners) != 1 {
+        t.Fatalf("declared owner scope = %#v, matched %v", scope, matched)
+      }
+      scope = projectDiagnosticScopeForWatchedInput(uri, scope)
+      if !scope.all {
+        t.Fatalf("Program input scope remained owner-only: %#v", scope)
+      }
+
+      result := source.ProjectDiagnosticsForOwners(nil)
+
+      if result.selected != 2 || result.complete {
+        t.Fatalf("all-producer failed refresh = %#v", result)
+      }
+      if !strings.Contains(log.String(), first.Name) ||
+        !strings.Contains(log.String(), second.Name) {
+        t.Fatalf("Program input did not invoke both producers:\n%s", log.String())
+      }
+    })
+  }
+}

package/internal/lspserver/lsp_project_diagnostics_refresh_accumulates_owner_freshness_test.go

@@ -0,0 +1,65 @@
+package lspserver
+
+import "testing"
+
+// TestProjectDiagnosticsRefreshAccumulatesOwnerFreshness verifies separate
+// successful refreshes can jointly satisfy one affected-producer generation.
+func TestProjectDiagnosticsRefreshAccumulatesOwnerFreshness(t *testing.T) {
+  proxy := &Proxy{}
+  proxy.projectDiagnosticRefreshPending = true
+  proxy.pendingProjectDiagnosticGeneration = 2
+  proxy.pendingProjectDiagnosticOwners = map[string]struct{}{
+    "alpha": {},
+    "beta":  {},
+  }
+
+  if proxy.recordPendingProjectDiagnosticOwnersRefreshed(
+    1,
+    map[string]struct{}{"beta": {}},
+  ) {
+    t.Fatal("stale producer refresh completed the newer generation")
+  }
+  if _, pending := proxy.pendingProjectDiagnosticOwners["beta"]; !pending {
+    t.Fatal("stale producer refresh removed a newer pending owner")
+  }
+  if proxy.recordPendingProjectDiagnosticOwnersRefreshed(
+    2,
+    map[string]struct{}{"alpha": {}},
+  ) {
+    t.Fatal("one producer completed a two-producer refresh")
+  }
+  if _, pending := proxy.pendingProjectDiagnosticOwners["alpha"]; pending {
+    t.Fatal("successful producer remained pending")
+  }
+  if _, pending := proxy.pendingProjectDiagnosticOwners["beta"]; !pending {
+    t.Fatal("failed producer was removed from pending scope")
+  }
+  if !proxy.recordPendingProjectDiagnosticOwnersRefreshed(
+    2,
+    map[string]struct{}{"beta": {}},
+  ) {
+    t.Fatal("separate producer successes did not complete the generation")
+  }
+
+  // A newer watched event can arrive after record reports completion but
+  // before its caller clears the old generation. The newer scope must survive
+  // that rejected completion unchanged.
+  proxy.projectDiagnosticGeneration = 3
+  proxy.pendingProjectDiagnosticGeneration = 3
+  proxy.projectDiagnosticRefreshPending = true
+  proxy.pendingProjectDiagnosticOwners = map[string]struct{}{"alpha": {}}
+  proxy.completePendingProjectDiagnosticRefresh(2)
+  proxy.projectRefreshMu.Lock()
+  defer proxy.projectRefreshMu.Unlock()
+  if !proxy.projectDiagnosticRefreshPending ||
+    proxy.pendingProjectDiagnosticGeneration != 3 {
+    t.Fatalf(
+      "newer pending generation was cleared: pending %v, generation %d",
+      proxy.projectDiagnosticRefreshPending,
+      proxy.pendingProjectDiagnosticGeneration,
+    )
+  }
+  if _, pending := proxy.pendingProjectDiagnosticOwners["alpha"]; !pending {
+    t.Fatal("newer pending owner was cleared by the prior generation")
+  }
+}

package/internal/lspserver/lsp_project_diagnostics_refresh_keeps_each_producer_last_good_test.go

@@ -0,0 +1,90 @@
+package lspserver
+
+import "testing"
+
+// TestLSPProjectDiagnosticsRefreshKeepsEachProducerLastGood verifies partial
+// refreshes update only the producers that answered successfully.
+//
+// Project diagnostics are one merged config-URI publication, but their
+// sidecars fail independently. Rebuilding that publication from only the
+// current call's successes would erase a failed producer's prior findings. An
+// empty successful answer is different: it deliberately clears that producer.
+//
+//  1. Seed two producers with successful publications.
+//  2. Refresh only the first and assert the second producer's last-good remains.
+//  3. Clear the second with a successful empty publication.
+//  4. Recover the second and assert manifest-order aggregation is restored.
+func TestLSPProjectDiagnosticsRefreshKeepsEachProducerLastGood(t *testing.T) {
+  first := NativeLSPPluginEntry{Binary: "first", Name: "@ttsc/first"}
+  second := NativeLSPPluginEntry{Binary: "second", Name: "@ttsc/second"}
+  source := &NativePluginSource{
+    plugins: []NativeLSPPluginEntry{first, second},
+  }
+  publication := func(codes ...string) *LSPProjectDiagnostics {
+    diagnostics := make([]LSPDiagnostic, 0, len(codes))
+    for _, code := range codes {
+      diagnostics = append(diagnostics, LSPDiagnostic{
+        Code:    code,
+        Message: code,
+      })
+    }
+    return &LSPProjectDiagnostics{
+      URI:         "file:///project/tsconfig.json",
+      Diagnostics: diagnostics,
+    }
+  }
+  codes := func(got *LSPProjectDiagnostics) []string {
+    if got == nil {
+      return nil
+    }
+    out := make([]string, 0, len(got.Diagnostics))
+    for _, diagnostic := range got.Diagnostics {
+      out = append(out, diagnostic.Code.(string))
+    }
+    return out
+  }
+  assertCodes := func(label string, got *LSPProjectDiagnostics, want ...string) {
+    t.Helper()
+    actual := codes(got)
+    if len(actual) != len(want) {
+      t.Fatalf("%s codes = %v, want %v", label, actual, want)
+    }
+    for index := range want {
+      if actual[index] != want[index] {
+        t.Fatalf("%s codes = %v, want %v", label, actual, want)
+      }
+    }
+  }
+
+  source.storeProjectDiagnostics(first, 1, publication("first-old"))
+  source.storeProjectDiagnostics(second, 1, publication("second-old"))
+  assertCodes(
+    "initial",
+    source.projectDiagnosticsSnapshot(),
+    "first-old",
+    "second-old",
+  )
+
+  source.storeProjectDiagnostics(first, 2, publication("first-new"))
+  assertCodes(
+    "partial failure",
+    source.projectDiagnosticsSnapshot(),
+    "first-new",
+    "second-old",
+  )
+
+  source.storeProjectDiagnostics(second, 3, publication())
+  assertCodes(
+    "successful clear",
+    source.projectDiagnosticsSnapshot(),
+    "first-new",
+  )
+
+  source.storeProjectDiagnostics(second, 4, publication("second-new"))
+  assertCodes(
+    "recovery",
+    source.projectDiagnosticsSnapshot(),
+    "first-new",
+    "second-new",
+  )
+}

package/internal/lspserver/lsp_project_diagnostics_refreshes_only_input_owners_test.go

@@ -0,0 +1,62 @@
+package lspserver
+
+import (
+  "bytes"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLSPProjectDiagnosticsRefreshesOnlyInputOwners verifies flattened client
+// watch registration does not erase contributor ownership.
+//
+//  1. Give two diagnostics-capable producers disjoint exact input snapshots.
+//  2. Resolve the first input's owner from the merged source.
+//  3. Refresh that owner and assert the unrelated producer is never invoked.
+func TestLSPProjectDiagnosticsRefreshesOnlyInputOwners(t *testing.T) {
+  root := t.TempDir()
+  first := NativeLSPPluginEntry{
+    Binary:             "ttsc-no-such-first-owner-sidecar",
+    Name:               "@ttsc/first",
+    ProjectDiagnostics: true,
+    ProjectInputs:      true,
+  }
+  second := NativeLSPPluginEntry{
+    Binary:             "ttsc-no-such-second-owner-sidecar",
+    Name:               "@ttsc/second",
+    ProjectDiagnostics: true,
+    ProjectInputs:      true,
+  }
+  var log bytes.Buffer
+  source := &NativePluginSource{
+    err:     &log,
+    plugins: []NativeLSPPluginEntry{first, second},
+  }
+  firstInput := filepath.Join(root, "docs", "first.md")
+  source.storeProjectInputs(first, 1, LSPProjectInputSnapshot{
+    Root:  filepath.ToSlash(root),
+    Files: []string{filepath.ToSlash(firstInput)},
+  })
+  source.storeProjectInputs(second, 1, LSPProjectInputSnapshot{
+    Root: filepath.ToSlash(root),
+    Files: []string{
+      filepath.ToSlash(filepath.Join(root, "docs", "second.md")),
+    },
+  })
+  owners := source.ProjectInputOwnersForURI(testFileURI(firstInput))
+  if len(owners) != 1 || owners[0] != pluginKey(first) {
+    t.Fatalf("first input owners = %#v", owners)
+  }
+
+  result := source.ProjectDiagnosticsForOwners(owners)
+
+  if result.selected != 1 || result.complete {
+    t.Fatalf("scoped failed refresh = %#v", result)
+  }
+  if !strings.Contains(log.String(), first.Name) {
+    t.Fatalf("owned producer was not invoked:\n%s", log.String())
+  }
+  if strings.Contains(log.String(), second.Name) {
+    t.Fatalf("unrelated producer was invoked:\n%s", log.String())
+  }
+}