ttsc 0.19.2 → 0.20.0

package/internal/lspserver/lsp_native_completion_hints_grouped_compatibility_boundary_test.go

@@ -0,0 +1,60 @@
+package lspserver
+
+import (
+  "reflect"
+  "testing"
+)
+
+// TestNativeCompletionHintsKeepGroupedWireAndRejectInvalidEntries verifies the
+// compatibility and validation boundary.
+//
+// Third-party sidecars may already publish the grouped shape documented by the
+// first proxy implementation. Those responses remain valid, while empty items,
+// empty triggers, and structurally malformed JSON must not enter the corpus.
+//
+//  1. Decode a grouped response containing valid and empty entries.
+//  2. Assert the valid group's item order survives and empty entries are dropped.
+//  3. Assert a field with the wrong JSON type rejects the response.
+func TestNativeCompletionHintsKeepGroupedWireAndRejectInvalidEntries(t *testing.T) {
+  body := []byte(`[
+    {
+      "scope":"jsdoc",
+      "after":"@legacy ",
+      "items":[
+        {"insert":"legacy-first","detail":"kept"},
+        {"insert":""},
+        {"insert":"legacy-second"}
+      ]
+    },
+    {"scope":"","after":"@missing-scope ","items":[{"insert":"drop"}]},
+    {"scope":"jsdoc","after":"","items":[{"insert":"drop"}]},
+    {"scope":"jsdoc","after":"@empty ","items":[]},
+    {"insert":"","trigger":{"scope":"jsdoc","after":"@flat-empty "}},
+    {"insert":"drop","trigger":{"scope":"","after":"@flat-empty-scope "}},
+    {"insert":"drop","trigger":{"scope":"jsdoc","after":""}},
+    {}
+  ]`)
+
+  got, err := decodeNativeCompletionHints(body)
+  if err != nil {
+    t.Fatalf("decode grouped completion hints: %v", err)
+  }
+  want := []LSPCompletionHint{{
+    Scope: "jsdoc",
+    After: "@legacy ",
+    Items: []LSPCompletionItem{
+      {Insert: "legacy-first", Detail: "kept"},
+      {Insert: "legacy-second"},
+    },
+  }}
+  if !reflect.DeepEqual(got, want) {
+    t.Errorf("grouped compatibility result:\n got %#v\nwant %#v", got, want)
+  }
+
+  malformed := []byte(`[
+    {"insert":42,"trigger":{"scope":"jsdoc","after":"@broken "}}
+  ]`)
+  if _, err := decodeNativeCompletionHints(malformed); err == nil {
+    t.Error("wrongly typed flat hint was accepted")
+  }
+}

package/internal/lspserver/lsp_native_plugin_source.go

@@ -63,8 +63,38 @@ type NativePluginSource struct {
 
   commandIDs      []string
   codeActionKinds []string
-  owners          map[string]NativeLSPPluginEntry
-  logMu           sync.Mutex
+
+  // completionHints is filled by a background fetch, so it needs a lock the
+  // static verbs do not: the proxy reads it from the completion path while
+  // discovery may still be writing it. It is the flattened publication-order
+  // view of pluginHints, materialized on every store so the completion path
+  // copies a ready slice instead of rebuilding one per keystroke.
+  hintsMu         sync.RWMutex
+  completionHints []LSPCompletionHint
+  // pluginHints keeps each producer's corpus separately, keyed by plugin
+  // identity, so one plugin's refresh cannot disturb another's. A producer's
+  // entry changes only when that producer answers successfully: a refresh that
+  // failed to run leaves the last known-good corpus in place rather than
+  // blanking a working corpus over a transient spawn failure.
+  pluginHints map[string]completionHintRecord
+  // hintsObserver is told after every completed refresh cycle so the proxy can
+  // react to a corpus that changed mid-session. Nil for any host that did not
+  // register one.
+  hintsObserver func()
+  // hintsRefresh serializes and coalesces corpus refreshes. A refresh loads a
+  // Program per plugin, so scheduling one per editor event without coalescing
+  // would stack process spawns behind each other.
+  hintsRefresh coalescingRefresh
+  owners       map[string]NativeLSPPluginEntry
+  logMu        sync.Mutex
+
+  // residentMu guards the resident-daemon table below. A resident sidecar keeps
+  // a warm Program across verbs, so lsp-diagnostics / lsp-code-actions reuse it
+  // instead of respawning per verb; serveUnsupported remembers a sidecar that
+  // predates lsp-serve so the source stops retrying it and stays on exec.
+  residentMu       sync.Mutex
+  residents        map[string]*residentSidecar
+  serveUnsupported map[string]bool
 }
 
 type limitedBuffer struct {
@@ -140,6 +170,15 @@ func NewNativePluginSource(opts NativePluginSourceOptions) (*NativePluginSource,
     owners:             map[string]NativeLSPPluginEntry{},
   }
   source.discoverCommandIDs()
+  // The corpus fetch loads a Program, so it runs off the construction path.
+  // Blocking here would delay initialize — and therefore the editor's first
+  // response — for a feature most projects do not use. Until it lands,
+  // CompletionHints answers nil and the editor sees exactly what it sees today.
+  //
+  // The first fetch goes through the same scheduler every later refresh uses,
+  // so startup and mid-session rediscovery share one generation counter and one
+  // coalescing rule rather than racing as two independent writers.
+  source.RefreshCompletionHints()
   return source, nil
 }
 
@@ -314,6 +353,256 @@ func (s *NativePluginSource) CommandIDs() []string {
   return out
 }
 
+// CompletionHints returns the corpus plugins published, or nil until it has
+// been fetched.
+//
+// Nil while loading is deliberate and is the whole reason the fetch is
+// asynchronous. Unlike lsp-command-ids and lsp-code-action-kinds — which ignore
+// their arguments and never build a Program — lsp-hints must load one, because
+// a corpus is a projection of what a project rule's Check found. Paying that on
+// the initialize path would delay every editor session for a feature most
+// projects do not use, and paying it on the first completion would freeze the
+// popup. Answering "no hints yet" degrades honestly: the editor still gets
+// tsgo's completion, and ours appear once they exist.
+//
+// The same reasoning carries to refresh. It answers the last known-good corpus
+// while a rediscovery scheduled by RefreshCompletionHints is running, so
+// completion never blocks on a producer and never observes a half-cleared
+// corpus.
+func (s *NativePluginSource) CompletionHints() []LSPCompletionHint {
+  if s == nil {
+    return nil
+  }
+  s.hintsMu.RLock()
+  defer s.hintsMu.RUnlock()
+  if len(s.completionHints) == 0 {
+    return nil
+  }
+  out := make([]LSPCompletionHint, len(s.completionHints))
+  copy(out, s.completionHints)
+  return out
+}
+
+// RefreshCompletionHints schedules one asynchronous corpus rediscovery.
+//
+// The corpus is a projection of what a project rule's Check found, so it goes
+// stale the moment the rule's inputs change: a saved contributor-indexed
+// document, a rule enabled in `lint.config.*`, a watched file rewritten outside
+// the editor. Without this the corpus stayed a session snapshot and only a
+// language-server restart could replace it.
+//
+// Asynchronous for the same reason the first fetch is (see CompletionHints):
+// the editor event that schedules a refresh must not wait for a Program load.
+// Concurrent requests coalesce into at most one queued rerun, so a save storm
+// costs one extra refresh rather than one per notification, and the previous
+// corpus keeps answering completion until the new one lands.
+func (s *NativePluginSource) RefreshCompletionHints() {
+  if s == nil || len(s.plugins) == 0 {
+    return
+  }
+  s.hintsRefresh.schedule(s.discoverCompletionHints)
+}
+
+// SetCompletionHintsObserver registers fn to run after each completed refresh
+// cycle. The proxy uses it to notice a trigger character that appeared after
+// the initialize response was already sent. A nil fn clears the observer.
+func (s *NativePluginSource) SetCompletionHintsObserver(fn func()) {
+  if s == nil {
+    return
+  }
+  s.hintsMu.Lock()
+  defer s.hintsMu.Unlock()
+  s.hintsObserver = fn
+}
+
+// completionHintRecord is one producer's corpus and the refresh generation that
+// produced it. The generation is what keeps a slow refresh from overwriting a
+// newer one: plugin fetches run sequentially inside a cycle, but two cycles can
+// still be in flight when a scheduled refresh outlives its successor's start.
+type completionHintRecord struct {
+  hints      []LSPCompletionHint
+  generation uint64
+}
+
+// discoverCompletionHints fetches every plugin's corpus for one generation.
+//
+// A separate pass from discoverCommandIDs rather than another step inside it.
+// That loop abandons the rest of a plugin's discovery on any error, so folding
+// hints in would mean a plugin whose corpus failed also lost its code action
+// kinds — one optional feature taking down a working one.
+//
+// Each plugin's result is stored as it arrives instead of after the whole pass,
+// so a fast producer's fresh corpus reaches the editor without waiting on a slow
+// one, and a producer that failed keeps serving what it last published.
+func (s *NativePluginSource) discoverCompletionHints(generation uint64) {
+  for _, plugin := range s.plugins {
+    body, err := s.run(plugin, "lsp-hints")
+    if err != nil {
+      // Silent, unlike every other discovery failure here. A plugin that does
+      // not know this verb rejects it as an unknown command, and that is the
+      // common case rather than the exceptional one: every plugin built before
+      // this channel existed, forever. Logging it would print an error per
+      // plugin per session for an optional feature nobody asked those plugins
+      // for — the same reasoning that makes CompletionHints an optional
+      // interface rather than a PluginSource method.
+      //
+      // The cost is that a plugin genuinely broken while producing hints also
+      // goes quiet. That is the right trade: its hints are absent either way,
+      // and the alternative is punishing every well-behaved old plugin to catch
+      // a rare new one. Refresh strengthens that trade rather than weakening it:
+      // a logged failure would now print per save instead of per session.
+      continue
+    }
+    published, err := decodeNativeCompletionHints(body)
+    if err != nil {
+      // Not silent. A plugin that answered and answered wrongly implements the
+      // verb and got it wrong, which is worth saying — unlike one that never
+      // implemented it at all.
+      s.log("ttscserver: %s lsp-hints returned invalid JSON: %v", pluginLabel(plugin), err)
+      continue
+    }
+    s.storeCompletionHints(plugin, generation, published)
+  }
+  s.notifyCompletionHintsObserver()
+}
+
+// storeCompletionHints replaces one producer's corpus and rebuilds the flattened
+// snapshot the completion path reads.
+//
+// A successful answer is the only thing that changes a producer's corpus, and an
+// empty successful answer clears it — that is how a disabled rule's items stop
+// being offered. An older generation is dropped: refresh cycles are scheduled by
+// editor events, and the last event's answer is the one the user is waiting for.
+func (s *NativePluginSource) storeCompletionHints(plugin NativeLSPPluginEntry, generation uint64, hints []LSPCompletionHint) {
+  key := pluginKey(plugin)
+  s.hintsMu.Lock()
+  defer s.hintsMu.Unlock()
+  if existing, ok := s.pluginHints[key]; ok && generation < existing.generation {
+    return
+  }
+  if s.pluginHints == nil {
+    s.pluginHints = map[string]completionHintRecord{}
+  }
+  s.pluginHints[key] = completionHintRecord{hints: hints, generation: generation}
+  s.completionHints = s.flattenCompletionHintsLocked()
+}
+
+// flattenCompletionHintsLocked concatenates every producer's corpus in manifest
+// order. Order is load-bearing twice over: the proxy resolves overlapping hints
+// by publication order, and the editor ranks the items it is handed. Iterating
+// the manifest rather than the map keeps that order identical across refreshes,
+// which a Go map's randomized range would not. The caller holds hintsMu.
+func (s *NativePluginSource) flattenCompletionHintsLocked() []LSPCompletionHint {
+  hints := []LSPCompletionHint{}
+  seen := make(map[string]struct{}, len(s.plugins))
+  for _, plugin := range s.plugins {
+    key := pluginKey(plugin)
+    if _, duplicate := seen[key]; duplicate {
+      continue
+    }
+    seen[key] = struct{}{}
+    hints = append(hints, s.pluginHints[key].hints...)
+  }
+  return hints
+}
+
+// notifyCompletionHintsObserver runs the registered observer outside hintsMu:
+// the observer reads the corpus back through CompletionHints, and holding the
+// lock across it would deadlock on the RLock.
+func (s *NativePluginSource) notifyCompletionHintsObserver() {
+  s.hintsMu.RLock()
+  observer := s.hintsObserver
+  s.hintsMu.RUnlock()
+  if observer != nil {
+    observer()
+  }
+}
+
+// pluginKey identifies one manifest entry. It matches the identity
+// pluginOwnsCommand compares, so a manifest carrying the same binary under two
+// stages keeps two independent corpora instead of overwriting one with the
+// other.
+func pluginKey(plugin NativeLSPPluginEntry) string {
+  return plugin.Binary + "\x00" + plugin.Name + "\x00" + plugin.Stage
+}
+
+// decodeNativeCompletionHints accepts both generations of the lsp-hints wire.
+//
+// @ttsc/lint publishes one flat rule.Hint per item, with the scope and trigger
+// nested under `trigger`. The first proxy implementation instead documented a
+// grouped response with `scope`, `after`, and `items` at the top level. Flat
+// entries are grouped here by trigger so the proxy keeps its efficient matching
+// shape, while grouped responses remain valid for existing third-party
+// sidecars. The first occurrence of a trigger fixes its group position and each
+// later occurrence appends in publication order, preserving rule ranking.
+func decodeNativeCompletionHints(body []byte) ([]LSPCompletionHint, error) {
+  var entries []json.RawMessage
+  if err := json.Unmarshal(body, &entries); err != nil {
+    return nil, err
+  }
+
+  type triggerKey struct {
+    scope string
+    after string
+  }
+  flatGroups := map[triggerKey]int{}
+  hints := make([]LSPCompletionHint, 0, len(entries))
+  for _, entry := range entries {
+    var fields map[string]json.RawMessage
+    if err := json.Unmarshal(entry, &fields); err != nil {
+      return nil, err
+    }
+    if _, grouped := fields["items"]; grouped {
+      var hint LSPCompletionHint
+      if err := json.Unmarshal(entry, &hint); err != nil {
+        return nil, err
+      }
+      hint.Items = usableNativeCompletionItems(hint.Items)
+      if hint.Scope == "" || hint.After == "" || len(hint.Items) == 0 {
+        continue
+      }
+      hints = append(hints, hint)
+      continue
+    }
+
+    var flat struct {
+      LSPCompletionItem
+      Trigger struct {
+        Scope string `json:"scope"`
+        After string `json:"after"`
+      } `json:"trigger"`
+    }
+    if err := json.Unmarshal(entry, &flat); err != nil {
+      return nil, err
+    }
+    if flat.Insert == "" || flat.Trigger.Scope == "" || flat.Trigger.After == "" {
+      continue
+    }
+    key := triggerKey{scope: flat.Trigger.Scope, after: flat.Trigger.After}
+    index, exists := flatGroups[key]
+    if !exists {
+      index = len(hints)
+      flatGroups[key] = index
+      hints = append(hints, LSPCompletionHint{
+        Scope: flat.Trigger.Scope,
+        After: flat.Trigger.After,
+      })
+    }
+    hints[index].Items = append(hints[index].Items, flat.LSPCompletionItem)
+  }
+  return hints, nil
+}
+
+func usableNativeCompletionItems(items []LSPCompletionItem) []LSPCompletionItem {
+  kept := make([]LSPCompletionItem, 0, len(items))
+  for _, item := range items {
+    if item.Insert != "" {
+      kept = append(kept, item)
+    }
+  }
+  return kept
+}
+
 // CodeActionKinds returns the action kinds discovered from LSP-capable sidecars.
 func (s *NativePluginSource) CodeActionKinds() []string {
   if s == nil || len(s.codeActionKinds) == 0 {
@@ -385,6 +674,30 @@ func (s *NativePluginSource) pluginOwnsCommand(plugin NativeLSPPluginEntry, comm
 }
 
 func (s *NativePluginSource) run(plugin NativeLSPPluginEntry, command string, args ...string) ([]byte, error) {
+  // Route the Program-loading read verbs through the plugin's resident daemon so
+  // a warm Program is reused across verbs. serveRun returns served=false for a
+  // sidecar that predates lsp-serve or a transport failure, falling back to the
+  // spawn-per-verb path below with no behavior change. The static discovery
+  // verbs (lsp-command-ids / lsp-code-action-kinds) and lsp-execute-command stay
+  // on exec by design.
+  if command == serveVerbDiagnostics || command == serveVerbCodeActions {
+    if body, served, err := s.serveRun(plugin, command, args); served {
+      return body, err
+    }
+  }
+  if command == serveVerbHints {
+    // Hints join the daemon on a weaker condition than the other two: the
+    // answer is used only when it arrives without error. A sidecar built after
+    // the daemon landed but before this verb joined it answers lsp-serve and
+    // rejects lsp-hints as an unknown verb, which reaches this side as a
+    // nonzero code — indistinguishable over this protocol from a rule that
+    // failed. Falling back to the spawn path on any nonzero reply keeps that
+    // sidecar's corpus working, and a project whose hints genuinely fail pays
+    // one extra spawn to fail there too, exactly as it did before.
+    if body, served, err := s.serveRun(plugin, command, args); served && err == nil {
+      return body, nil
+    }
+  }
   return s.runWithStdin(plugin, command, nil, args...)
 }