ttsc 0.19.2 → 0.20.0

package/internal/graphsymbols/provider.go

@@ -188,7 +188,7 @@ func (pr *Provider) References(uri string, pos lspserver.LSPPosition, includeDec
     if e.To != target.ID || isStructuralEdge(e.Kind) {
       continue
     }
-    f := nodeFile(e.From)
+    f := graph.NodeFile(e.From)
     if f == "" {
       continue
     }
@@ -196,7 +196,7 @@ func (pr *Provider) References(uri string, pos lspserver.LSPPosition, includeDec
   }
   if includeDeclaration {
     declText := sources[target.File]
-    add(target.File, firstCodeOffset(declText, target.Pos), target.End)
+    add(target.File, graph.FirstCodeOffset(declText, target.Pos), target.End)
   }
   return locations, nil
 }
@@ -241,7 +241,7 @@ func buildSymbol(n *graph.Node, childrenOf map[string][]*graph.Node, text string
 }
 
 func nodeToSymbol(n *graph.Node, text string) lspserver.LSPDocumentSymbol {
-  start := firstCodeOffset(text, n.Pos)
+  start := graph.FirstCodeOffset(text, n.Pos)
   end := n.End
   if end < start {
     end = start
@@ -322,7 +322,7 @@ func targetNodeAt(g *graph.Graph, file string, offset int) *graph.Node {
     return best
   }
   for _, e := range g.Edges {
-    if !pathsEqual(nodeFile(e.From), file) {
+    if !pathsEqual(graph.NodeFile(e.From), file) {
       continue
     }
     if offset >= e.Pos && offset < e.End {
@@ -359,15 +359,6 @@ func sortNodes(nodes []*graph.Node) {
   })
 }
 
-// nodeFile recovers the source file path embedded in a node id
-// ("path#name:kind"); "" for an id without a path.
-func nodeFile(id string) string {
-  if hash := strings.Index(id, "#"); hash >= 0 {
-    return id[:hash]
-  }
-  return ""
-}
-
 // fileFromURI maps a file:// uri onto the source map key for the same file,
 // returning that key so text lookups by it succeed. Paths are compared
 // case-insensitively so a Windows drive-letter case mismatch between the
@@ -423,42 +414,10 @@ func uriFromFile(path string) string {
   return (&url.URL{Scheme: "file", Path: slashed}).String()
 }
 
-// firstCodeOffset advances past leading trivia (whitespace, // and /* */
-// comments) so a declaration span starts at the keyword rather than its doc
-// comment or indentation. It mirrors the graph dump's own trivia skip.
-func firstCodeOffset(text string, pos int) int {
-  if pos < 0 {
-    return 0
-  }
-  i := pos
-  for i < len(text) {
-    switch {
-    case text[i] == ' ' || text[i] == '\t' || text[i] == '\r' || text[i] == '\n':
-      i++
-    case text[i] == '/' && i+1 < len(text) && text[i+1] == '/':
-      i += 2
-      for i < len(text) && text[i] != '\n' {
-        i++
-      }
-    case text[i] == '/' && i+1 < len(text) && text[i+1] == '*':
-      i += 2
-      for i+1 < len(text) && !(text[i] == '*' && text[i+1] == '/') {
-        i++
-      }
-      if i+1 < len(text) {
-        i += 2
-      } else {
-        i = len(text)
-      }
-    default:
-      return i
-    }
-  }
-  return i
-}
-
 // offsetToPosition converts a byte offset into an LSP Position (0-based line,
-// UTF-16 code-unit column).
+// UTF-16 code-unit column). The column unit is the session's negotiated
+// PositionEncodingKind, which the proxy's constrainInitializePositionEncoding
+// pins to UTF-16 for every ttscserver session.
 func offsetToPosition(text string, offset int) lspserver.LSPPosition {
   if offset < 0 {
     offset = 0
@@ -466,19 +425,12 @@ func offsetToPosition(text string, offset int) lspserver.LSPPosition {
   if offset > len(text) {
     offset = len(text)
   }
-  line := 0
-  lineStart := 0
-  for i := 0; i < offset; {
-    r, size := utf8.DecodeRuneInString(text[i:])
-    if size == 0 {
-      break
-    }
-    if r == '\n' {
-      line++
-      lineStart = i + size
-    }
-    i += size
+  starts := graph.ECMALineStarts(text)
+  line := sort.Search(len(starts), func(i int) bool { return starts[i] > offset }) - 1
+  if line < 0 {
+    line = 0
   }
+  lineStart := starts[line]
   character := 0
   for i := lineStart; i < offset; {
     r, size := utf8.DecodeRuneInString(text[i:])
@@ -495,54 +447,37 @@ func offsetToPosition(text string, offset int) lspserver.LSPPosition {
   return lspserver.LSPPosition{Line: line, Character: character}
 }
 
-// lspPositionToOffset converts an LSP Position (0-based line, UTF-16 column)
-// into a byte offset. It returns (offset, false) when the position points past
-// the end of the text so the caller can treat it as "no symbol here".
+// lspPositionToOffset converts an LSP Position (0-based line, UTF-16 column —
+// the encoding the proxy's constrainInitializePositionEncoding pins for every
+// ttscserver session) into a byte offset. It returns (offset, false) when the
+// position points past the end of the text so the caller can treat it as "no
+// symbol here".
 func lspPositionToOffset(text string, pos lspserver.LSPPosition) (int, bool) {
   if pos.Line < 0 || pos.Character < 0 {
     return 0, false
   }
-  i := 0
-  line := 0
-  for line < pos.Line {
-    if i >= len(text) {
-      return len(text), false
-    }
-    r, size := utf8.DecodeRuneInString(text[i:])
-    if size == 0 {
-      return len(text), false
-    }
-    if r == '\r' {
-      i += size
-      if i < len(text) && text[i] == '\n' {
-        i++
-      }
-      line++
-      continue
-    }
-    if r == '\n' {
-      i += size
-      line++
-      continue
-    }
-    i += size
+  starts := graph.ECMALineStarts(text)
+  if pos.Line >= len(starts) {
+    return len(text), false
   }
+  i := starts[pos.Line]
+  lineEnd := graph.LineEnd(text, starts, pos.Line)
   units := 0
   for units < pos.Character {
-    if i >= len(text) {
+    if i >= lineEnd {
       return len(text), false
     }
     r, size := utf8.DecodeRuneInString(text[i:])
     if size == 0 {
       return len(text), false
     }
-    if r == '\n' || r == '\r' {
-      return i, false
-    }
     n := utf16.RuneLen(r)
     if n <= 0 {
       n = 1
     }
+    if units+n > pos.Character {
+      return i, false
+    }
     units += n
     i += size
   }

package/internal/lspserver/lsp_clean_didopen_refreshes_compiler_state_test.go

@@ -0,0 +1,144 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "io"
+  "os"
+  "path/filepath"
+  "strings"
+  "sync"
+  "testing"
+)
+
+// recordingResidentSource is a PluginSource that also implements the resident
+// invalidator, recording every InvalidateResidentPrograms call so a test can
+// assert both that an invalidation happened and how it was localized.
+//
+// A clean open schedules its diagnostics on a goroutine that holds this same
+// source, so the recording is mutex-guarded: the assertions below read it while
+// that goroutine may still be running.
+type recordingResidentSource struct {
+  NullPluginSource
+  mu    sync.Mutex
+  calls [][]string
+}
+
+func (s *recordingResidentSource) InvalidateResidentPrograms(uris ...string) {
+  s.mu.Lock()
+  defer s.mu.Unlock()
+  s.calls = append(s.calls, append([]string(nil), uris...))
+}
+
+func (s *recordingResidentSource) recorded() [][]string {
+  s.mu.Lock()
+  defer s.mu.Unlock()
+  return append([][]string(nil), s.calls...)
+}
+
+// recordingSymbolProvider counts Invalidate calls; the two answer methods are
+// never reached by these notification tests. Invalidate is only ever called from
+// the notification path, which is the test's own goroutine.
+type recordingSymbolProvider struct{ invalidations int }
+
+func (p *recordingSymbolProvider) DocumentSymbols(string) ([]LSPDocumentSymbol, error) {
+  return nil, nil
+}
+
+func (p *recordingSymbolProvider) References(string, LSPPosition, bool) ([]LSPLocation, error) {
+  return nil, nil
+}
+
+func (p *recordingSymbolProvider) Invalidate() { p.invalidations++ }
+
+// testFileURI renders an absolute path as the file URI an editor would send.
+func testFileURI(path string) string {
+  return "file:///" + strings.TrimPrefix(filepath.ToSlash(path), "/")
+}
+
+func didOpenEnvelope(uri string, text string) Envelope {
+  params, _ := json.Marshal(map[string]any{
+    "textDocument": map[string]any{
+      "uri":        uri,
+      "languageId": "typescript",
+      "version":    1,
+      "text":       text,
+    },
+  })
+  return Envelope{JSONRPC: "2.0", Method: methodDidOpen, Params: params}
+}
+
+// TestLSPCleanDidOpenRefreshesCompilerState verifies that opening a document
+// whose buffer already matches disk refreshes both compiler-backed caches, while
+// opening a dirty buffer still refreshes neither.
+//
+// The resident lint Program and the graph symbol provider stay warm for the
+// whole editor session, and before this only didSave refreshed them. A document
+// closed across a branch switch, a `git pull`, or an edit from a second editor
+// therefore came back with diagnostics computed over the pre-change AST and
+// published against the new buffer. Equality with today's disk is not evidence
+// that the warm Program was built from today's disk, so the clean branch is
+// exactly the branch that must invalidate — and the dirty branch, which reports
+// nothing at all until the buffer reaches disk, must keep not invalidating.
+//
+//  1. Write a file, open it with the same text, and assert both caches were
+//     refreshed and the resident refresh named that document's URI.
+//  2. Open a second file with text that differs from disk.
+//  3. Assert neither cache was refreshed and the notification still forwards.
+func TestLSPCleanDidOpenRefreshesCompilerState(t *testing.T) {
+  dir := t.TempDir()
+  clean := filepath.Join(dir, "clean.ts")
+  if err := os.WriteFile(clean, []byte("export const value = 1;\n"), 0o600); err != nil {
+    t.Fatalf("write clean source: %v", err)
+  }
+  cleanURI := testFileURI(clean)
+
+  plugins := &recordingResidentSource{}
+  symbols := &recordingSymbolProvider{}
+  proxy := NewProxy(ProxyOptions{
+    EditorOut:      io.Discard,
+    UpstreamIn:     io.Discard,
+    Source:         plugins,
+    SymbolProvider: symbols,
+  })
+
+  handled, err := proxy.handleEditorEnvelope(
+    didOpenEnvelope(cleanURI, "export const value = 1;\n"),
+    nil,
+  )
+  if err != nil {
+    t.Fatalf("clean didOpen: %v", err)
+  }
+  if handled {
+    t.Fatal("clean didOpen was answered locally instead of forwarded to tsgo")
+  }
+  if symbols.invalidations != 1 {
+    t.Errorf("clean didOpen symbol invalidations = %d, want 1", symbols.invalidations)
+  }
+  if len(plugins.recorded()) != 1 {
+    t.Fatalf("clean didOpen resident invalidations = %d, want 1", len(plugins.recorded()))
+  }
+  if len(plugins.recorded()[0]) != 1 || plugins.recorded()[0][0] != cleanURI {
+    t.Errorf("clean didOpen resident invalidation = %v, want the opened uri %q", plugins.recorded()[0], cleanURI)
+  }
+
+  dirty := filepath.Join(dir, "dirty.ts")
+  if err := os.WriteFile(dirty, []byte("export const value = 1;\n"), 0o600); err != nil {
+    t.Fatalf("write dirty source: %v", err)
+  }
+  handled, err = proxy.handleEditorEnvelope(
+    didOpenEnvelope(testFileURI(dirty), "export const value = 2;\n"),
+    nil,
+  )
+  if err != nil {
+    t.Fatalf("dirty didOpen: %v", err)
+  }
+  if handled {
+    t.Fatal("dirty didOpen was answered locally instead of forwarded to tsgo")
+  }
+  if symbols.invalidations != 1 {
+    t.Errorf("dirty didOpen refreshed the symbol provider: invalidations = %d, want 1", symbols.invalidations)
+  }
+  if len(plugins.recorded()) != 1 {
+    t.Errorf("dirty didOpen refreshed the resident daemon: calls = %v, want only the clean open's", plugins.recorded())
+  }
+}

package/internal/lspserver/lsp_completion.go

@@ -0,0 +1,109 @@
+package lspserver
+
+import "strings"
+
+// completionScopeJSDoc is the one scope a hint may claim today. It mirrors
+// rule.HintScopeJSDoc; the wire carries the string, not the Go constant.
+const completionScopeJSDoc = "jsdoc"
+
+// matchCompletionHints returns the items that apply at a cursor, and the prefix
+// the editor should filter them against.
+//
+// The cursor-nearest matching After wins; at the same occurrence, the longest
+// trigger wins. That lets a corpus be layered without a query language while
+// ensuring a later trigger is never eclipsed by an earlier, longer one. Rules
+// merge only when they name the same trigger at the winning occurrence.
+func matchCompletionHints(
+  hints []LSPCompletionHint,
+  linePrefix string,
+  inJSDoc bool,
+) (items []LSPCompletionItem, filter string) {
+  bestStart := -1
+  bestLength := -1
+  bestAfter := ""
+  for _, hint := range hints {
+    if !completionHintApplies(hint, linePrefix, inJSDoc) {
+      continue
+    }
+    start := strings.LastIndex(linePrefix, hint.After)
+    if start < bestStart || (start == bestStart && len(hint.After) < bestLength) {
+      continue
+    }
+    if start > bestStart || len(hint.After) > bestLength {
+      bestStart = start
+      bestLength = len(hint.After)
+      bestAfter = hint.After
+      items = nil
+      filter = linePrefix[start+len(hint.After):]
+    }
+    if start != bestStart || hint.After != bestAfter {
+      continue
+    }
+    items = append(items, hint.Items...)
+  }
+  return items, filter
+}
+
+func completionHintApplies(
+  hint LSPCompletionHint,
+  linePrefix string,
+  inJSDoc bool,
+) bool {
+  return completionHintCouldApply(hint, linePrefix) && inJSDoc
+}
+
+// completionHintCouldApply reports every part of a hint's admission that does
+// not depend on where the cursor sits lexically: that the hint has something to
+// offer, that its scope is one this host knows, and that its trigger literal is
+// on the current line.
+//
+// Split out because the remaining condition is the expensive one. Deciding the
+// cursor's scope scans the document from byte zero, while all of this reads one
+// line, so a caller can find out whether that scan can change any answer before
+// paying for it.
+func completionHintCouldApply(hint LSPCompletionHint, linePrefix string) bool {
+  if hint.After == "" || len(hint.Items) == 0 {
+    return false
+  }
+  if hint.Scope != completionScopeJSDoc {
+    // An unknown scope is refused rather than ignored. Treating it as
+    // "anywhere" would make a hint from a newer plugin than this host fire in
+    // every string literal — the one place a wrong guess is most visible and
+    // least explicable.
+    return false
+  }
+  return strings.Contains(linePrefix, hint.After)
+}
+
+// anyCompletionHintCouldApply reports whether the cursor's lexical scope can
+// change any hint's answer here, and therefore whether it is worth deciding.
+//
+// When it answers false, completionHintApplies refuses every hint on grounds
+// the scope cannot rescue, so the document scan behind that decision would
+// produce an answer nothing reads. That is the overwhelmingly common case while
+// typing: a corpus triggers on "@" or "@evidence ", and most lines hold neither.
+func anyCompletionHintCouldApply(hints []LSPCompletionHint, linePrefix string) bool {
+  for _, hint := range hints {
+    if completionHintCouldApply(hint, linePrefix) {
+      return true
+    }
+  }
+  return false
+}
+
+// linePrefixAt returns the text from the start of the cursor's line up to the
+// cursor.
+//
+// This is what a trigger matches against. It stops at the line start because a
+// trigger is line-local by construction: a corpus that could match across lines
+// would need the enclosing declaration, which the proxy does not have.
+func linePrefixAt(text string, offset int) string {
+  if offset < 0 || offset > len(text) {
+    return ""
+  }
+  head := text[:offset]
+  if start := strings.LastIndexAny(head, "\r\n"); start != -1 {
+    return head[start+1:]
+  }
+  return head
+}

package/internal/lspserver/lsp_completion_gate_never_refuses_a_matching_line_test.go

@@ -0,0 +1,50 @@
+package lspserver
+
+import "testing"
+
+// TestLSPCompletionGateNeverRefusesAMatchingLine verifies the cheap line test
+// that now guards the document scan admits everything the full match would.
+//
+// completionItemsFor decides the cursor's lexical scope by scanning the document
+// from byte zero, and that answer is only ever read by a hint whose trigger is
+// already on the current line. The gate skips the scan when no trigger is, so it
+// must never be stricter than the match it precedes: a false where
+// matchCompletionHints would have produced items is a hint silently lost.
+//
+//  1. Publish a layered corpus: a broad trigger and two narrower ones.
+//  2. For each candidate line, run the gate and the full match together.
+//  3. Assert the gate is open wherever the match produced items, and closed on
+//     lines holding no trigger at all.
+func TestLSPCompletionGateNeverRefusesAMatchingLine(t *testing.T) {
+  hints := []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "param"}}},
+    {Scope: "jsdoc", After: "@evidence ", Items: []LSPCompletionItem{{Insert: "docs/spec.md"}}},
+    {Scope: "jsdoc", After: "@evidence docs/spec.md#", Items: []LSPCompletionItem{{Insert: "pricing"}}},
+    // Refused by the match for want of items; must not open the gate either.
+    {Scope: "jsdoc", After: "@nothing", Items: nil},
+    // An empty trigger matches every line; the match refuses it, so must the gate.
+    {Scope: "jsdoc", After: "", Items: []LSPCompletionItem{{Insert: "never"}}},
+  }
+
+  for _, entry := range []struct {
+    line string
+    open bool
+  }{
+    {" * @par", true},
+    {" * @evidence docs/sp", true},
+    {" * @evidence docs/spec.md#pri", true},
+    {" * plain prose with no tag", false},
+    {"", false},
+    {"const value = 1;", false},
+    {" * @nothing here", true}, // the broad "@" trigger still applies
+  } {
+    gate := anyCompletionHintCouldApply(hints, entry.line)
+    if gate != entry.open {
+      t.Fatalf("gate for %q: want %v, got %v", entry.line, entry.open, gate)
+    }
+    items, _ := matchCompletionHints(hints, entry.line, true)
+    if len(items) > 0 && !gate {
+      t.Fatalf("gate closed on %q while the match produced %d items", entry.line, len(items))
+    }
+  }
+}

package/internal/lspserver/lsp_completion_hints_longest_trigger_wins_test.go

@@ -0,0 +1,149 @@
+package lspserver
+
+import "testing"
+
+// TestLSPCompletionHintsLongestTriggerWins pins the rule that makes a hint
+// corpus layerable.
+//
+// A plugin publishes broad and narrow triggers at once — `@`, `@evidence `,
+// `@evidence docs/spec.md#` — because it cannot ask a question per keystroke and
+// so must describe every position up front. Only the longest match may answer.
+// Without that, typing `@evidence docs/spec.md#pri` would offer tag names,
+// document paths, and anchors together, and the narrow corpus the user actually
+// wants would be buried under the broad one that also matches.
+//
+//  1. Publish three nested triggers.
+//  2. Ask at a cursor inside the narrowest.
+//  3. Assert only the narrowest answers, and that the filter is the text after
+//     it rather than the whole line.
+func TestLSPCompletionHintsLongestTriggerWins(t *testing.T) {
+  hints := []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "evidence"}}},
+    {Scope: "jsdoc", After: "@evidence ", Items: []LSPCompletionItem{{Insert: "docs/spec.md"}}},
+    {Scope: "jsdoc", After: "@evidence docs/spec.md#", Items: []LSPCompletionItem{
+      {Insert: "pricing"},
+      {Insert: "refunds"},
+    }},
+  }
+
+  cases := []struct {
+    line   string
+    want   []string
+    filter string
+  }{
+    {" * @evi", []string{"evidence"}, "evi"},
+    {" * @evidence docs/sp", []string{"docs/spec.md"}, "docs/sp"},
+    {" * @evidence docs/spec.md#pri", []string{"pricing", "refunds"}, "pri"},
+    // The boundary that makes the filter meaningful: at the trigger's own edge
+    // the filter is empty and everything is offered.
+    {" * @evidence docs/spec.md#", []string{"pricing", "refunds"}, ""},
+  }
+  for _, entry := range cases {
+    items, filter := matchCompletionHints(hints, entry.line, true)
+    got := inserts(items)
+    if !equalStrings(got, entry.want) {
+      t.Errorf("line %q offered %v, want %v", entry.line, got, entry.want)
+    }
+    if filter != entry.filter {
+      t.Errorf("line %q filtered on %q, want %q", entry.line, filter, entry.filter)
+    }
+  }
+}
+
+// TestLSPCompletionHintsRefuseOutsideScope pins the negative twin.
+//
+// A line prefix alone cannot tell `@evidence` in a doc comment from
+// `@Injectable` above a class — both end in `@`. Scope is what separates them,
+// and a corpus that ignored it would fire in every decorator position. An
+// unknown scope is refused for the same reason: a hint from a newer plugin than
+// this host must contribute nothing rather than fire everywhere.
+//
+//  1. Ask the same line outside a JSDoc block.
+//  2. Ask with a scope this host does not know.
+//  3. Assert silence in both.
+func TestLSPCompletionHintsRefuseOutsideScope(t *testing.T) {
+  hints := []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "evidence"}}},
+  }
+  if items, _ := matchCompletionHints(hints, "@Inj", false); len(items) != 0 {
+    t.Errorf("a decorator position was offered %v, want nothing", inserts(items))
+  }
+
+  future := []LSPCompletionHint{
+    {Scope: "markdown", After: "@", Items: []LSPCompletionItem{{Insert: "nope"}}},
+  }
+  if items, _ := matchCompletionHints(future, " * @", true); len(items) != 0 {
+    t.Errorf("an unknown scope was offered %v, want nothing", inserts(items))
+  }
+
+  empty := []LSPCompletionHint{
+    {Scope: "jsdoc", After: "", Items: []LSPCompletionItem{{Insert: "nope"}}},
+    {Scope: "jsdoc", After: "@", Items: nil},
+  }
+  if items, _ := matchCompletionHints(empty, " * @", true); len(items) != 0 {
+    t.Errorf("a degenerate hint was offered %v, want nothing", inserts(items))
+  }
+}
+
+// TestCursorInJSDocTracksTheBlock pins the scope test itself.
+//
+// It is a backward scan rather than a parse, so the cases that matter are the
+// ones where a naive "is there a /** before me" would be wrong: after the block
+// closed, and inside a line comment that only looks like one.
+//
+//  1. A cursor inside an open block is in scope.
+//  2. A cursor after the block closed is not.
+//  3. A line comment is never a doc comment.
+func TestCursorInJSDocTracksTheBlock(t *testing.T) {
+  cases := []struct {
+    text string
+    want bool
+  }{
+    {"/**\n * @evi", true},
+    {"/** @evi", true},
+    {"/**\n * ok\n */\nconst x = @", false},
+    {"// @evi", false},
+    {"const x = 1; @", false},
+    // A second block after a closed one: the open must win again.
+    {"/** a */\n/**\n * @evi", true},
+  }
+  for _, entry := range cases {
+    if got := cursorInJSDoc(entry.text, len(entry.text)); got != entry.want {
+      t.Errorf("cursorInJSDoc(%q) = %v, want %v", entry.text, got, entry.want)
+    }
+  }
+}
+
+// TestLinePrefixStopsAtTheLine pins that a trigger is line-local.
+//
+// A trigger matched against the whole document would let a `@evidence` three
+// lines up offer anchors on an unrelated line.
+func TestLinePrefixStopsAtTheLine(t *testing.T) {
+  text := "/**\n * @evidence docs/spec.md#pri"
+  if got, want := linePrefixAt(text, len(text)), " * @evidence docs/spec.md#pri"; got != want {
+    t.Errorf("linePrefixAt = %q, want %q", got, want)
+  }
+  if got := linePrefixAt("no newline", 2); got != "no" {
+    t.Errorf("linePrefixAt with no newline = %q, want %q", got, "no")
+  }
+}
+
+func inserts(items []LSPCompletionItem) []string {
+  out := []string{}
+  for _, item := range items {
+    out = append(out, item.Insert)
+  }
+  return out
+}
+
+func equalStrings(a, b []string) bool {
+  if len(a) != len(b) {
+    return false
+  }
+  for i := range a {
+    if a[i] != b[i] {
+      return false
+    }
+  }
+  return true
+}

package/internal/lspserver/lsp_completion_hints_nearest_trigger_wins_test.go

@@ -0,0 +1,37 @@
+package lspserver
+
+import "testing"
+
+// TestLSPCompletionHintsNearestTriggerWins keeps completion tied to the trigger
+// nearest the cursor, not merely the longest text somewhere earlier on the
+// line. At one occurrence, nested triggers remain layerable and duplicate
+// producers of the same trigger may contribute together.
+func TestLSPCompletionHintsNearestTriggerWins(t *testing.T) {
+  hints := []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "broad"}}},
+    {Scope: "jsdoc", After: "@task", Items: []LSPCompletionItem{{Insert: "task"}}},
+    {Scope: "jsdoc", After: "@bird", Items: []LSPCompletionItem{{Insert: "bird"}}},
+    {Scope: "jsdoc", After: "@fish", Items: []LSPCompletionItem{{Insert: "fish"}}},
+    {Scope: "jsdoc", After: "@note", Items: []LSPCompletionItem{{Insert: "first"}}},
+    {Scope: "jsdoc", After: "@note", Items: []LSPCompletionItem{{Insert: "second"}}},
+  }
+
+  for _, entry := range []struct {
+    line   string
+    want   []string
+    filter string
+  }{
+    {" * @task details @", []string{"broad"}, ""},
+    {" * @task details", []string{"task"}, " details"},
+    {" * @bird then @fish tail", []string{"fish"}, " tail"},
+    {" * @note draft", []string{"first", "second"}, " draft"},
+  } {
+    items, filter := matchCompletionHints(hints, entry.line, true)
+    if got := inserts(items); !equalStrings(got, entry.want) {
+      t.Errorf("line %q offered %v, want %v", entry.line, got, entry.want)
+    }
+    if filter != entry.filter {
+      t.Errorf("line %q filtered on %q, want %q", entry.line, filter, entry.filter)
+    }
+  }
+}