ttsc 0.19.2 → 0.20.0

package/internal/lspserver/lsp_completion_scope_ignores_jsdoc_bytes_in_literals_test.go

@@ -0,0 +1,108 @@
+package lspserver
+
+import "testing"
+
+// TestLSPCompletionScopeIgnoresJSDocBytesInLiterals pins the lexical table the
+// JSDoc scope decision rests on.
+//
+// `/**` is three ordinary bytes. A string, a template, a regex class, and a line
+// comment can all contain them, and a backward search for the nearest opener
+// calls every one of those positions a doc comment — which is how
+// `const example = "/** @par"` came to be offered JSDoc tag completions. Every
+// impostor below is a position that search answered wrongly; every real block
+// below is what stops a replacement from passing by refusing everything.
+//
+//  1. Put the cursor after JSDoc-shaped bytes in every token kind that can hold
+//     them.
+//  2. Assert the scanner's scope and the `cursorInJSDoc` answer derived from it.
+//  3. Keep a real block adjacent to each impostor, so a scanner that simply
+//     refused everything could not pass.
+func TestLSPCompletionScopeIgnoresJSDocBytesInLiterals(t *testing.T) {
+  cases := []struct {
+    name string
+    text string
+    want lexicalScope
+  }{
+    {name: "real block", text: "/** @par", want: lexicalScopeJSDoc},
+    {name: "multi line block", text: "/**\n * ok\n * @par", want: lexicalScopeJSDoc},
+    // The buffer an editor sends on Windows, with prose the rule may cite.
+    {name: "crlf block with non ascii prose", text: "/**\r\n * 가격 😀\r\n * @par", want: lexicalScopeJSDoc},
+    {name: "closed block", text: "/** ok */ @par", want: lexicalScopeCode},
+    {name: "empty block comment", text: "/**/ @par", want: lexicalScopeCode},
+    {name: "plain block comment", text: "/* @par", want: lexicalScopeBlockComment},
+    {name: "line comment", text: "// /** @par", want: lexicalScopeLineComment},
+    // CR ends a line for TypeScript, so a CR-only buffer must not leave the
+    // rest of the file inside one `//`.
+    {name: "line comment ended by a lone cr", text: "// note\r/** @par", want: lexicalScopeJSDoc},
+    {name: "line comment ended by crlf", text: "// note\r\n/** @par", want: lexicalScopeJSDoc},
+    {name: "no delimiter", text: "const x = 1; @par", want: lexicalScopeCode},
+
+    {name: "double quoted string", text: "const x = \"/** @par", want: lexicalScopeString},
+    {name: "single quoted string", text: "const x = '/** @par", want: lexicalScopeString},
+    {name: "template literal", text: "const x = `/** @par", want: lexicalScopeTemplate},
+    // The interpolation returns to code, so the template text after it is still
+    // template text.
+    {name: "template after interpolation", text: "const x = `${ y } /** @par", want: lexicalScopeTemplate},
+    {name: "string inside interpolation", text: "const x = `${ \"/** @par", want: lexicalScopeString},
+    {name: "nested template inside interpolation", text: "const x = `${ `inner /** @par", want: lexicalScopeTemplate},
+    // A comment inside an interpolation is a real comment: nesting must not be
+    // answered by refusing everything under a backtick.
+    {name: "block comment inside interpolation", text: "const x = `${ /** @par", want: lexicalScopeJSDoc},
+    // An escaped quote does not end the string.
+    {name: "escaped quote inside string", text: "const x = 'it\\'s /** @par", want: lexicalScopeString},
+    // An escaped backslash does end it, so the block that follows is real.
+    {name: "escaped backslash ends the string", text: "const x = \"a\\\\\" /** @par", want: lexicalScopeJSDoc},
+    // A backslash before CRLF is one line continuation, so the string keeps
+    // going and the line-end recovery must not fire on that `\n`.
+    {name: "escaped crlf continues the string", text: "const s = \"a\\\r\nb /** @par", want: lexicalScopeString},
+    {name: "block after a string holding the opener", text: "const x = \"/**\";\n/** @par", want: lexicalScopeJSDoc},
+    // A `*/` inside a string closes nothing, so the block after it still opens.
+    {name: "block after a string holding the terminator", text: "const x = \"*/\";\n/** @par", want: lexicalScopeJSDoc},
+    // The mirror image: a quote inside a doc comment is prose, not a string.
+    {name: "quote inside a block", text: "/** the user's @par", want: lexicalScopeJSDoc},
+    // A live buffer is usually invalid mid-edit. Without line-end recovery one
+    // stray quote would hide every doc comment below it.
+    {name: "unterminated string recovers at the line end", text: "const bad = \"oops\nconst y = 1;\n/** @par", want: lexicalScopeJSDoc},
+
+    {name: "regex class holding the opener", text: "const re = /[/**]/; @par", want: lexicalScopeCode},
+    // Without regex skipping the quote in the class would open a string and
+    // swallow the real block that follows on the same line.
+    {name: "block after a regex holding a quote", text: "const re = /[\"]/; /** @par", want: lexicalScopeJSDoc},
+    {name: "regex after a keyword", text: "function f() { return /[\"]/; } /** @par", want: lexicalScopeJSDoc},
+    // The negative twin: `/` after a value divides, and reading it as a literal
+    // would swallow the block that follows.
+    {name: "division is not a regex", text: "const ratio = a / b; /** @par", want: lexicalScopeJSDoc},
+    // A keyword is a legal property name, and a member access is a value.
+    {name: "keyword as a property name divides", text: "const n = obj.in / 2; /** @par", want: lexicalScopeJSDoc},
+    // What follows a completed literal divides, flags or not.
+    {name: "division after a flagless regex", text: "const n = /re/ / 2; /** @par", want: lexicalScopeJSDoc},
+  }
+
+  for _, entry := range cases {
+    offset := len(entry.text)
+    if got := lexicalScopeAt(entry.text, offset); got != entry.want {
+      t.Errorf("%s: lexicalScopeAt(%q, %d) = %s, want %s", entry.name, entry.text, offset, got, entry.want)
+    }
+    wantJSDoc := entry.want == lexicalScopeJSDoc
+    if got := cursorInJSDoc(entry.text, offset); got != wantJSDoc {
+      t.Errorf("%s: cursorInJSDoc(%q, %d) = %v, want %v", entry.name, entry.text, offset, got, wantJSDoc)
+    }
+  }
+
+  // A cursor before the opener is outside the block the opener will start.
+  if got := lexicalScopeAt("/** @par", 0); got != lexicalScopeCode {
+    t.Errorf("a cursor before the opener is in %s, want code", got)
+  }
+  // A cursor inside a terminated regex literal is inside the literal, not in
+  // the comment its bytes spell. Offset 15 is the second `*` of the character
+  // class, the byte a backward search reads as an open doc comment.
+  if got := lexicalScopeAt("const re = /[/**]/; @par", 15); got != lexicalScopeRegex {
+    t.Errorf("a cursor inside a regex literal is in %s, want regex", got)
+  }
+
+  // Out-of-range offsets stay refusals rather than panics, because the position
+  // comes from the editor and the buffer from the proxy's own splice.
+  if cursorInJSDoc("/** @par", -1) || cursorInJSDoc("/** @par", 99) {
+    t.Error("an out-of-range offset must be refused rather than answered")
+  }
+}

package/internal/lspserver/lsp_completion_scope_refuses_regex_hints_test.go

@@ -0,0 +1,52 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+type regexScopeCompletionHintSource struct{ NullPluginSource }
+
+func (regexScopeCompletionHintSource) CompletionHints() []LSPCompletionHint {
+  return []LSPCompletionHint{{
+    Scope: "jsdoc",
+    After: "@tag",
+    Items: []LSPCompletionItem{{Insert: "tag"}},
+  }}
+}
+
+// TestLSPCompletionScopeRefusesRegexHints verifies the request path never
+// offers JSDoc hints inside a regex while still offering one in a real JSDoc
+// block immediately after executable code.
+func TestLSPCompletionScopeRefusesRegexHints(t *testing.T) {
+  const uri = "file:///project/src/main.ts"
+  proxy := &Proxy{source: regexScopeCompletionHintSource{}}
+  regex := "if /* c */ (ok) /[/** @tag]/.test(value)"
+  real := "const value = 1;\n/** @tag"
+
+  if pending := completionScopePending(proxy, uri, regex, 0, strings.Index(regex, "@tag")+4); len(pending.items) != 0 {
+    t.Fatalf("regex completion items = %#v, want none", pending.items)
+  }
+  if pending := completionScopePending(proxy, uri, real, 1, len("/** @tag")); len(pending.items) != 1 {
+    t.Fatalf("real JSDoc completion items = %#v, want one", pending.items)
+  }
+}
+
+func completionScopePending(
+  proxy *Proxy,
+  uri string,
+  text string,
+  line int,
+  character int,
+) pendingCompletionRequest {
+  proxy.documentText = map[string]string{uri: text}
+  params, _ := json.Marshal(map[string]any{
+    "textDocument": map[string]any{"uri": uri},
+    "position": map[string]any{
+      "line":      line,
+      "character": character,
+    },
+  })
+  return proxy.completionItemsFor(Envelope{Params: params})
+}

package/internal/lspserver/lsp_completion_trigger_uses_last_rune_test.go

@@ -0,0 +1,24 @@
+package lspserver
+
+import (
+  "reflect"
+  "testing"
+)
+
+type unicodeCompletionTriggerSource struct{ NullPluginSource }
+
+func (unicodeCompletionTriggerSource) CompletionHints() []LSPCompletionHint {
+  return []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@"},
+    {Scope: "jsdoc", After: "문서／"},
+  }
+}
+
+func TestLSPCompletionTriggerUsesLastRune(t *testing.T) {
+  proxy := &Proxy{source: unicodeCompletionTriggerSource{}}
+  got := proxy.pluginCompletionTriggerCharacters()
+  want := []string{"@", "／"}
+  if !reflect.DeepEqual(got, want) {
+    t.Fatalf("trigger characters = %#v, want %#v", got, want)
+  }
+}

package/internal/lspserver/lsp_deleted_watched_file_withdraws_plugin_diagnostics_test.go

@@ -0,0 +1,110 @@
+package lspserver
+
+import (
+  "bytes"
+  "encoding/json"
+  "io"
+  "testing"
+)
+
+// TestLSPDeletedWatchedFileWithdrawsPluginDiagnostics verifies that deleting a
+// file on disk removes the findings ttsc last published for it, while leaving
+// the compiler's own diagnostics for the same document alone.
+//
+// Dropping the warm Program is not enough on its own. An open document's content
+// belongs to the client rather than to disk, so the compiler has no reason to
+// republish for a URI whose file was deleted underneath it, and without that
+// republish nothing triggers the merge that would replace ttsc's cached set. The
+// user would keep looking at lint findings for a file that no longer exists.
+//
+//  1. Seed one upstream and one plugin diagnostic for a document.
+//  2. Send a watched-file deletion for that document.
+//  3. Assert the republished set keeps the upstream diagnostic and drops the
+//     plugin one, and that a plain change publishes nothing by itself.
+func TestLSPDeletedWatchedFileWithdrawsPluginDiagnostics(t *testing.T) {
+  const uri = "file:///project/src/gone.ts"
+  var editor bytes.Buffer
+  proxy := NewProxy(ProxyOptions{
+    EditorOut:  &editor,
+    UpstreamIn: io.Discard,
+    Source:     NullPluginSource{},
+  })
+  proxy.rememberUpstreamDiagnostics(uri, nil, []json.RawMessage{
+    json.RawMessage(`{"message":"from the compiler"}`),
+  })
+  proxy.rememberPluginDiagnostics(uri, nil, []LSPDiagnostic{{Message: "from the rule"}})
+
+  deletion, _ := json.Marshal(map[string]any{
+    "changes": []any{map[string]any{"uri": uri, "type": fileChangeTypeDeleted}},
+  })
+  handled, err := proxy.handleEditorEnvelope(Envelope{
+    JSONRPC: "2.0",
+    Method:  methodDidChangeWatchedFiles,
+    Params:  deletion,
+  }, nil)
+  if err != nil {
+    t.Fatalf("watched-file deletion: %v", err)
+  }
+  if handled {
+    t.Fatal("watched-file deletion was swallowed instead of forwarded to tsgo")
+  }
+
+  _, body, err := NewFrameReader(bytes.NewReader(editor.Bytes())).Read()
+  if err != nil {
+    t.Fatalf("read republished diagnostics: %v", err)
+  }
+  published := decodePublishedDiagnostics(t, body)
+  if published.URI != uri {
+    t.Fatalf("republished uri = %q, want %q", published.URI, uri)
+  }
+  if len(published.Diagnostics) != 1 {
+    t.Fatalf("republished %d diagnostics, want only the compiler's: %s", len(published.Diagnostics), body)
+  }
+  if published.Diagnostics[0].Message != "from the compiler" {
+    t.Errorf("republished diagnostic = %q, want the compiler's", published.Diagnostics[0].Message)
+  }
+
+  // Negative twin: an ordinary edit withdraws nothing. Its findings are still
+  // valid until the sidecar recomputes them, and the ordinary republish path
+  // owns that replacement.
+  editor.Reset()
+  proxy.rememberPluginDiagnostics(uri, nil, []LSPDiagnostic{{Message: "from the rule"}})
+  change, _ := json.Marshal(map[string]any{
+    "changes": []any{map[string]any{"uri": uri, "type": fileChangeTypeChanged}},
+  })
+  if _, err := proxy.handleEditorEnvelope(Envelope{
+    JSONRPC: "2.0",
+    Method:  methodDidChangeWatchedFiles,
+    Params:  change,
+  }, nil); err != nil {
+    t.Fatalf("watched-file change: %v", err)
+  }
+  if editor.Len() != 0 {
+    t.Errorf("a plain watched-file change republished diagnostics: %s", editor.Bytes())
+  }
+}
+
+// publishedDiagnostics is the slice of a publishDiagnostics notification this
+// test asserts on: which document it targets and the message of each entry.
+type publishedDiagnostics struct {
+  URI         string `json:"uri"`
+  Diagnostics []struct {
+    Message string `json:"message"`
+  } `json:"diagnostics"`
+}
+
+func decodePublishedDiagnostics(t *testing.T, body []byte) publishedDiagnostics {
+  t.Helper()
+  env, err := ParseEnvelope(body)
+  if err != nil {
+    t.Fatalf("parse published frame: %v", err)
+  }
+  if env.Method != methodPublishDiagnostics {
+    t.Fatalf("published method = %q, want %q", env.Method, methodPublishDiagnostics)
+  }
+  var params publishedDiagnostics
+  if err := json.Unmarshal(env.Params, &params); err != nil {
+    t.Fatalf("decode published diagnostics: %v\n%s", err, body)
+  }
+  return params
+}

package/internal/lspserver/lsp_didsave_keeps_the_incremental_changed_uri_path_test.go

@@ -0,0 +1,78 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "io"
+  "testing"
+)
+
+// incrementalSaveSource records how a save and a dirty edit reach the daemon.
+type incrementalSaveSource struct {
+  NullPluginSource
+  calls [][]string
+}
+
+func (s *incrementalSaveSource) InvalidateResidentPrograms(uris ...string) {
+  s.calls = append(s.calls, append([]string(nil), uris...))
+}
+
+// TestLSPDidSaveKeepsTheIncrementalChangedURIPath verifies the two boundaries the
+// new open and watched-file invalidations must not erode: a save of a known
+// source still travels as one changed URI, and a didChange on a dirty buffer
+// still sends the resident daemon nothing at all.
+//
+// The resident daemon exists to avoid a cold parse+bind+checker per verb. A save
+// that degraded into a full reload, or an invalidation per keystroke, would trade
+// exactly that away — so widening the set of signals that reach the daemon has to
+// leave these two untouched.
+//
+//  1. Save a document and assert the daemon is told that one URI changed.
+//  2. Send a ranged didChange for the same document.
+//  3. Assert no further resident invalidation was recorded.
+func TestLSPDidSaveKeepsTheIncrementalChangedURIPath(t *testing.T) {
+  const uri = "file:///project/src/main.ts"
+  plugins := &incrementalSaveSource{}
+  proxy := NewProxy(ProxyOptions{
+    EditorOut:  io.Discard,
+    UpstreamIn: io.Discard,
+    Source:     plugins,
+  })
+
+  saveParams, _ := json.Marshal(map[string]any{
+    "textDocument": map[string]any{"uri": uri},
+  })
+  if _, err := proxy.handleEditorEnvelope(Envelope{
+    JSONRPC: "2.0",
+    Method:  methodDidSave,
+    Params:  saveParams,
+  }, nil); err != nil {
+    t.Fatalf("didSave: %v", err)
+  }
+  if len(plugins.calls) != 1 {
+    t.Fatalf("didSave resident invalidations = %v, want exactly one", plugins.calls)
+  }
+  if len(plugins.calls[0]) != 1 || plugins.calls[0][0] != uri {
+    t.Errorf("didSave resident invalidation = %v, want the incremental changed uri %q", plugins.calls[0], uri)
+  }
+
+  changeParams, _ := json.Marshal(map[string]any{
+    "textDocument": map[string]any{"uri": uri, "version": 2},
+    "contentChanges": []any{map[string]any{
+      "range": map[string]any{
+        "start": map[string]any{"line": 0, "character": 0},
+        "end":   map[string]any{"line": 0, "character": 0},
+      },
+      "text": "x",
+    }},
+  })
+  if _, err := proxy.handleEditorEnvelope(Envelope{
+    JSONRPC: "2.0",
+    Method:  methodDidChange,
+    Params:  changeParams,
+  }, nil); err != nil {
+    t.Fatalf("didChange: %v", err)
+  }
+  if len(plugins.calls) != 1 {
+    t.Errorf("didChange on a dirty buffer reached the resident daemon: calls = %v", plugins.calls)
+  }
+}

package/internal/lspserver/lsp_hints_absence_is_not_an_error_test.go

@@ -0,0 +1,46 @@
+package lspserver
+
+import (
+  "bytes"
+  "testing"
+)
+
+// TestLSPHintsAbsenceIsNotAnError pins that a plugin without the hint verb is
+// silent, not broken.
+//
+// Every plugin built before this channel existed rejects `lsp-hints` as an
+// unknown command, and that is permanent and universal rather than a
+// transitional state. Treating it as a discovery failure would print an error
+// per plugin per editor session, forever, for a feature those plugins were never
+// asked to provide. It is the optional-interface reasoning applied to the wire:
+// absence is an answer.
+//
+// A real sidecar that cannot run reaches the same path as one that rejects the
+// verb — both return an error from run — so an unresolvable binary is a faithful
+// stand-in and keeps the test from needing a compiled fixture.
+//
+//  1. Discover hints from a plugin whose sidecar cannot answer.
+//  2. Assert the corpus is empty.
+//  3. Assert nothing was written to the log.
+func TestLSPHintsAbsenceIsNotAnError(t *testing.T) {
+  var log bytes.Buffer
+  source := &NativePluginSource{
+    err: &log,
+    plugins: []NativeLSPPluginEntry{
+      {Binary: "ttsc-no-such-plugin-binary", Name: "@ttsc/legacy"},
+    },
+  }
+
+  source.discoverCompletionHints(1)
+
+  if hints := source.CompletionHints(); len(hints) != 0 {
+    t.Errorf("a plugin that could not answer contributed %d hints", len(hints))
+  }
+  if log.Len() != 0 {
+    t.Errorf(
+      "a plugin without the hint verb was logged as a failure:\n%s\n"+
+        "every plugin predating this channel would print that every session",
+      log.String(),
+    )
+  }
+}

package/internal/lspserver/lsp_hints_refresh_coalesces_concurrent_requests_test.go

@@ -0,0 +1,82 @@
+package lspserver
+
+import (
+  "sync"
+  "testing"
+  "time"
+)
+
+// TestLSPHintsRefreshCoalescesConcurrentRequests pins the scheduler that keeps
+// rediscovery off the editor's hot path.
+//
+// One refresh costs a process spawn and a Program load per plugin, and the
+// events that schedule it arrive in bursts: a multi-file save, a formatter
+// rewriting several documents, a watched config change landing with them. Both
+// naive answers are wrong — running one refresh per event stacks spawns behind
+// each other, and dropping events while one runs leaves the corpus a generation
+// behind the edit that caused it. Exactly one rerun observes the newest state
+// for the cost of one refresh.
+//
+//  1. Hold a run open and schedule several more requests behind it.
+//  2. Release it and assert exactly one rerun followed, with a newer generation.
+//  3. Schedule again once idle and assert the refresher restarts.
+func TestLSPHintsRefreshCoalescesConcurrentRequests(t *testing.T) {
+  var refresh coalescingRefresh
+  started := make(chan struct{}, 8)
+  release := make(chan struct{})
+
+  var mu sync.Mutex
+  var generations []uint64
+  task := func(generation uint64) {
+    mu.Lock()
+    generations = append(generations, generation)
+    mu.Unlock()
+    started <- struct{}{}
+    <-release
+  }
+
+  refresh.schedule(task)
+  waitForRefreshRun(t, started, "the first scheduled refresh never ran")
+  for i := 0; i < 5; i++ {
+    refresh.schedule(task)
+  }
+  close(release)
+  waitForRefreshRun(t, started, "the coalesced requests never produced a rerun")
+
+  // Nothing else may follow: five requests during one run are one rerun, not
+  // five. A stray extra run would show up as a third start.
+  select {
+  case <-started:
+    t.Fatal("coalesced refresh requests ran more than once")
+  case <-time.After(200 * time.Millisecond):
+  }
+
+  mu.Lock()
+  ran := append([]uint64(nil), generations...)
+  mu.Unlock()
+  if len(ran) != 2 || ran[0] != 1 || ran[1] != 2 {
+    t.Fatalf("refresh generations = %v, want [1 2] — each run needs a newer stamp", ran)
+  }
+
+  // A request that arrives once the refresher is idle starts a fresh run rather
+  // than being swallowed by the finished one.
+  idle := make(chan uint64, 1)
+  refresh.schedule(func(generation uint64) { idle <- generation })
+  select {
+  case generation := <-idle:
+    if generation != 3 {
+      t.Fatalf("a refresh scheduled while idle ran as generation %d, want 3", generation)
+    }
+  case <-time.After(5 * time.Second):
+    t.Fatal("a refresh scheduled while idle never ran")
+  }
+}
+
+func waitForRefreshRun(t *testing.T, started <-chan struct{}, message string) {
+  t.Helper()
+  select {
+  case <-started:
+  case <-time.After(5 * time.Second):
+    t.Fatal(message)
+  }
+}

package/internal/lspserver/lsp_hints_refresh_ignores_a_superseded_generation_test.go

@@ -0,0 +1,40 @@
+package lspserver
+
+import "testing"
+
+// TestLSPHintsRefreshIgnoresASupersededGeneration pins the staleness guard.
+//
+// Refresh cycles are driven by editor events, and the answer the user is waiting
+// for is the newest one. A cycle that started earlier can still finish later —
+// its sidecar took longer, or a spawn was slow — and without a generation stamp
+// its result would silently restore the corpus the newer cycle just replaced.
+// The user would then see items for a rule they had already disabled, with no
+// event left to correct it.
+//
+//  1. Store a corpus produced by a newer generation.
+//  2. Store the older generation's result afterwards.
+//  3. Assert the newer corpus stands, and that a still-newer one replaces it.
+func TestLSPHintsRefreshIgnoresASupersededGeneration(t *testing.T) {
+  plugin := NativeLSPPluginEntry{Binary: "ttsc-lint", Name: "@ttsc/lint"}
+  source := &NativePluginSource{plugins: []NativeLSPPluginEntry{plugin}}
+
+  source.storeCompletionHints(plugin, 2, []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "returns"}}},
+  })
+  source.storeCompletionHints(plugin, 1, []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "stale"}}},
+  })
+
+  hints := source.CompletionHints()
+  if len(hints) != 1 || len(hints[0].Items) != 1 || hints[0].Items[0].Insert != "returns" {
+    t.Fatalf("an older refresh generation overwrote a newer corpus: %#v", hints)
+  }
+
+  source.storeCompletionHints(plugin, 3, []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "param"}}},
+  })
+  hints = source.CompletionHints()
+  if len(hints) != 1 || hints[0].Items[0].Insert != "param" {
+    t.Fatalf("the guard rejected a newer generation as well: %#v", hints)
+  }
+}

package/internal/lspserver/lsp_hints_refresh_keeps_each_producer_isolated_test.go

@@ -0,0 +1,64 @@
+package lspserver
+
+import (
+  "bytes"
+  "testing"
+)
+
+// TestLSPHintsRefreshKeepsEachProducerIsolated pins the failure boundary between
+// producers.
+//
+// A refresh re-asks every plugin, and plugins fail independently: one sidecar
+// can be mid-rebuild, locked by a virus scanner, or simply gone while the others
+// answer normally. A refresh that rebuilt one shared slice would let that single
+// failure blank a working producer's corpus — the editor would lose completions
+// it had a second ago for a reason unrelated to the rule that published them.
+// The rule is that only a producer's own successful answer changes its corpus.
+//
+//  1. Give two producers a good corpus.
+//  2. Run a whole refresh generation in which neither sidecar can be executed.
+//  3. Assert both corpora survived, in manifest order, with nothing logged.
+//  4. Let only the first producer answer, and assert the second is untouched.
+func TestLSPHintsRefreshKeepsEachProducerIsolated(t *testing.T) {
+  var log bytes.Buffer
+  first := NativeLSPPluginEntry{Binary: "ttsc-no-such-plugin-binary-a", Name: "@ttsc/lint"}
+  second := NativeLSPPluginEntry{Binary: "ttsc-no-such-plugin-binary-b", Name: "@samchon/evidence"}
+  source := &NativePluginSource{
+    err:     &log,
+    plugins: []NativeLSPPluginEntry{first, second},
+  }
+  source.storeCompletionHints(first, 1, []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "param"}}},
+  })
+  source.storeCompletionHints(second, 1, []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@evidence ", Items: []LSPCompletionItem{{Insert: "docs/rfc.md"}}},
+  })
+
+  source.discoverCompletionHints(2)
+
+  hints := source.CompletionHints()
+  if len(hints) != 2 || hints[0].After != "@" || hints[1].After != "@evidence " {
+    t.Fatalf("a refresh that could reach no producer disturbed the corpus: %#v", hints)
+  }
+  if log.Len() != 0 {
+    t.Errorf(
+      "a producer that could not answer was logged as a failure:\n%s\n"+
+        "refresh runs per save, so that line would print on every save",
+      log.String(),
+    )
+  }
+
+  source.storeCompletionHints(first, 3, []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "param"}, {Insert: "returns"}}},
+  })
+  hints = source.CompletionHints()
+  if len(hints) != 2 {
+    t.Fatalf("one producer's refresh changed the number of published hints: %#v", hints)
+  }
+  if len(hints[0].Items) != 2 {
+    t.Errorf("the refreshed producer still serves its old corpus: %#v", hints[0])
+  }
+  if hints[1].After != "@evidence " || len(hints[1].Items) != 1 {
+    t.Errorf("an unrelated producer's corpus was disturbed: %#v", hints[1])
+  }
+}