ttsc 0.19.2 → 0.20.0

package/internal/lspserver/lsp_completion_merges_into_upstream_response_test.go

@@ -0,0 +1,149 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "strings"
+  "testing"
+)
+
+// TestLSPCompletionMergesIntoUpstreamResponse pins the response merge.
+//
+// tsgo answers completion in three shapes — a bare item array, a CompletionList,
+// or null — and picks per request. Each has to be handled rather than assumed,
+// because guessing wrong does not error: it silently drops either the plugin's
+// items or the compiler's, and the user simply sees a shorter list than they
+// should. That is the failure this whole channel is most likely to ship with.
+//
+//  1. Merge into each of the three shapes.
+//  2. Assert upstream's items survive alongside the plugin's in every one.
+//  3. Assert isIncomplete stays upstream's answer, not ours.
+func TestLSPCompletionMergesIntoUpstreamResponse(t *testing.T) {
+  items := []LSPCompletionItem{{Insert: "pricing", Detail: "Pricing"}}
+
+  cases := []struct {
+    name       string
+    body       string
+    wantLabels []string
+    incomplete bool
+  }{
+    {
+      name:       "bare array",
+      body:       `{"jsonrpc":"2.0","id":1,"result":[{"label":"toString"}]}`,
+      wantLabels: []string{"toString", "pricing"},
+    },
+    {
+      name:       "completion list preserves isIncomplete",
+      body:       `{"jsonrpc":"2.0","id":1,"result":{"isIncomplete":true,"items":[{"label":"toString"}]}}`,
+      wantLabels: []string{"toString", "pricing"},
+      incomplete: true,
+    },
+    {
+      // Not an edge case: tsgo returns null for completion in JSDoc prose,
+      // which is exactly where these hints live. This is the common shape.
+      name:       "null result",
+      body:       `{"jsonrpc":"2.0","id":1,"result":null}`,
+      wantLabels: []string{"pricing"},
+    },
+  }
+  for _, entry := range cases {
+    merged := mergeCompletionResponse([]byte(entry.body), items)
+    var decoded struct {
+      Result struct {
+        IsIncomplete bool `json:"isIncomplete"`
+        Items        []struct {
+          Label      string `json:"label"`
+          InsertText string `json:"insertText"`
+          Detail     string `json:"detail"`
+        } `json:"items"`
+      } `json:"result"`
+    }
+    if err := json.Unmarshal(merged, &decoded); err != nil {
+      t.Fatalf("%s: merged body is not valid JSON: %v\n%s", entry.name, err, merged)
+    }
+    labels := []string{}
+    for _, item := range decoded.Result.Items {
+      labels = append(labels, item.Label)
+    }
+    if !equalStrings(labels, entry.wantLabels) {
+      t.Errorf("%s: merged labels %v, want %v", entry.name, labels, entry.wantLabels)
+    }
+    if decoded.Result.IsIncomplete != entry.incomplete {
+      t.Errorf(
+        "%s: isIncomplete = %v, want %v — the flag is upstream's to own",
+        entry.name, decoded.Result.IsIncomplete, entry.incomplete,
+      )
+    }
+  }
+
+  // A hint with no Label falls back to Insert, because the editor lists Label
+  // and an empty one renders as a blank row.
+  merged := mergeCompletionResponse([]byte(`{"jsonrpc":"2.0","id":1,"result":null}`), items)
+  if !strings.Contains(string(merged), `"label":"pricing"`) {
+    t.Errorf("an item without a Label must fall back to Insert:\n%s", merged)
+  }
+  if !strings.Contains(string(merged), `"insertText":"pricing"`) {
+    t.Errorf("insertText must carry Insert:\n%s", merged)
+  }
+}
+
+// TestLSPCompletionLeavesUpstreamErrorsAlone pins the negative twin.
+//
+// An upstream error is upstream's to report. Appending completions to it would
+// turn a failure into a half-answer that looks like it worked, which is worse
+// than the error the user was supposed to see.
+func TestLSPCompletionLeavesUpstreamErrorsAlone(t *testing.T) {
+  body := `{"jsonrpc":"2.0","id":1,"error":{"code":-32603,"message":"boom"}}`
+  if got := string(mergeCompletionResponse([]byte(body), []LSPCompletionItem{{Insert: "x"}})); got != body {
+    t.Errorf("an upstream error was rewritten:\n%s", got)
+  }
+
+  // Nothing to add is not a reason to rewrite a body either.
+  plain := `{"jsonrpc":"2.0","id":1,"result":[]}`
+  if got := string(mergeCompletionResponse([]byte(plain), nil)); got != plain {
+    t.Errorf("an empty contribution rewrote the body:\n%s", got)
+  }
+}
+
+// TestOffsetForPositionCountsUTF16 pins the position conversion.
+//
+// LSP counts a position's character in UTF-16 code units, not bytes. A line
+// holding an emoji or CJK text would otherwise land the cursor mid-token, and
+// the line prefix — which every trigger matches against — would be cut in the
+// wrong place. The failure is silent: completion just stops appearing on lines
+// with non-ASCII text.
+//
+//  1. Convert an ASCII position.
+//  2. Convert past CJK text, which is one UTF-16 unit but three bytes.
+//  3. Convert past an emoji, which is a surrogate pair — two units, four bytes.
+func TestOffsetForPositionCountsUTF16(t *testing.T) {
+  cases := []struct {
+    text      string
+    line      int
+    character int
+    want      string
+  }{
+    {"abc", 0, 2, "ab"},
+    {"/**\n * @evi", 1, 7, "/**\n * @evi"},
+    // 가격 is two runes, two UTF-16 units, six bytes.
+    {"// 가격 x", 0, 5, "// 가격"},
+    // An emoji past the BMP costs two units.
+    {"// 🚀 x", 0, 5, "// 🚀"},
+  }
+  for _, entry := range cases {
+    offset, ok := offsetForPosition(entry.text, entry.line, entry.character)
+    if !ok {
+      t.Errorf("offsetForPosition(%q, %d, %d) failed", entry.text, entry.line, entry.character)
+      continue
+    }
+    if got := entry.text[:offset]; got != entry.want {
+      t.Errorf(
+        "offsetForPosition(%q, %d, %d) cut at %q, want %q",
+        entry.text, entry.line, entry.character, got, entry.want,
+      )
+    }
+  }
+
+  if _, ok := offsetForPosition("one line", 5, 0); ok {
+    t.Error("a line past the end must fail rather than clamp silently")
+  }
+}

package/internal/lspserver/lsp_completion_nearest_hint_replaces_nearest_filter_test.go

@@ -0,0 +1,43 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "testing"
+)
+
+type nearestCompletionHintSource struct{ NullPluginSource }
+
+func (nearestCompletionHintSource) CompletionHints() []LSPCompletionHint {
+  return []LSPCompletionHint{
+    {Scope: "jsdoc", After: "@evidence", Items: []LSPCompletionItem{{Insert: "long"}}},
+    {Scope: "jsdoc", After: "@", Items: []LSPCompletionItem{{Insert: "near"}}},
+  }
+}
+
+// TestLSPCompletionNearestHintReplacesNearestFilter exercises the request path:
+// a later short trigger beats an earlier long trigger and replaces only the
+// filter immediately after the winning occurrence.
+func TestLSPCompletionNearestHintReplacesNearestFilter(t *testing.T) {
+  const uri = "file:///project/src/main.ts"
+  const text = "/** @evidence first @pa"
+  proxy := &Proxy{
+    source:       nearestCompletionHintSource{},
+    documentText: map[string]string{uri: text},
+  }
+  params, _ := json.Marshal(map[string]any{
+    "textDocument": map[string]any{"uri": uri},
+    "position":     map[string]any{"line": 0, "character": 23},
+  })
+
+  pending := proxy.completionItemsFor(Envelope{Params: params})
+  if len(pending.items) != 1 || pending.items[0].Insert != "near" {
+    t.Fatalf("items = %#v, want only the nearest trigger item", pending.items)
+  }
+  if !pending.hasRange {
+    t.Fatal("nearest trigger did not produce a replacement range")
+  }
+  if pending.replaceRange.Start != (LSPPosition{Line: 0, Character: 21}) ||
+    pending.replaceRange.End != (LSPPosition{Line: 0, Character: 23}) {
+    t.Errorf("replacement range = %+v, want character 21..23", pending.replaceRange)
+  }
+}

package/internal/lspserver/lsp_completion_preserves_completion_list_extensions_test.go

@@ -0,0 +1,99 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "reflect"
+  "testing"
+)
+
+// TestLSPCompletionPreservesCompletionListExtensions verifies lossless merging.
+//
+// TypeScript-Go uses CompletionList.itemDefaults, and newer protocol versions
+// may add more list-level fields. Decoding into a closed local struct silently
+// removed those fields whenever a plugin contributed even one completion.
+//
+//  1. Build an upstream CompletionList with itemDefaults, applyKind, and a future field.
+//  2. Merge one plugin completion.
+//  3. Assert every upstream list field and both items survive.
+func TestLSPCompletionPreservesCompletionListExtensions(t *testing.T) {
+  body := []byte(`{
+    "jsonrpc":"2.0",
+    "id":1,
+    "result":{
+      "isIncomplete":true,
+      "itemDefaults":{"commitCharacters":["."],"insertTextFormat":2,"data":{"session":"upstream","shared":"default"}},
+      "applyKind":{"commitCharacters":2,"data":2},
+      "x-future":{"nested":[1,2,3]},
+      "items":[{
+        "label":"upstream",
+        "labelDetails":{"detail":" kept"},
+        "commitCharacters":["("],
+        "data":{"shared":"item","token":42}
+      }]
+    }
+  }`)
+  merged := mergeCompletionResponse(body, []LSPCompletionItem{{Insert: "plugin"}})
+  var response struct {
+    Result map[string]json.RawMessage `json:"result"`
+  }
+  if err := json.Unmarshal(merged, &response); err != nil {
+    t.Fatalf("decode merged completion response: %v\n%s", err, merged)
+  }
+
+  assertJSON := func(field string, want string) {
+    t.Helper()
+    raw, exists := response.Result[field]
+    if !exists {
+      t.Errorf("CompletionList field %q was dropped", field)
+      return
+    }
+    var gotValue any
+    var wantValue any
+    if err := json.Unmarshal(raw, &gotValue); err != nil {
+      t.Errorf("decode field %q: %v", field, err)
+      return
+    }
+    if err := json.Unmarshal([]byte(want), &wantValue); err != nil {
+      t.Fatalf("decode expected field %q: %v", field, err)
+    }
+    if !reflect.DeepEqual(gotValue, wantValue) {
+      t.Errorf("CompletionList field %q = %s, want %s", field, raw, want)
+    }
+  }
+  assertJSON("itemDefaults", `{"commitCharacters":["."],"insertTextFormat":2,"data":{"session":"upstream","shared":"default"}}`)
+  assertJSON("applyKind", `{"commitCharacters":1,"data":1}`)
+  assertJSON("x-future", `{"nested":[1,2,3]}`)
+
+  var items []map[string]json.RawMessage
+  if err := json.Unmarshal(response.Result["items"], &items); err != nil {
+    t.Fatalf("decode merged items: %v", err)
+  }
+  if len(items) != 2 {
+    t.Fatalf("merged %d completion items, want upstream plus plugin", len(items))
+  }
+  assertItemJSON := func(index int, field string, want string) {
+    t.Helper()
+    raw, exists := items[index][field]
+    if !exists {
+      t.Errorf("item %d field %q was dropped", index, field)
+      return
+    }
+    var gotValue any
+    var wantValue any
+    if err := json.Unmarshal(raw, &gotValue); err != nil {
+      t.Errorf("decode item %d field %q: %v", index, field, err)
+      return
+    }
+    if err := json.Unmarshal([]byte(want), &wantValue); err != nil {
+      t.Fatalf("decode expected item %d field %q: %v", index, field, err)
+    }
+    if !reflect.DeepEqual(gotValue, wantValue) {
+      t.Errorf("item %d field %q = %s, want %s", index, field, raw, want)
+    }
+  }
+  assertItemJSON(0, "commitCharacters", `["(","."]`)
+  assertItemJSON(0, "data", `{"session":"upstream","shared":"item","token":42}`)
+  assertItemJSON(1, "commitCharacters", `[]`)
+  assertItemJSON(1, "data", `{"$ttsc":"ttsc/completion-hint/v1"}`)
+  assertJSON("isIncomplete", "true")
+}

package/internal/lspserver/lsp_completion_refuses_hints_inside_a_string_literal_test.go

@@ -0,0 +1,69 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "testing"
+)
+
+type jsdocTagCompletionHintSource struct{ NullPluginSource }
+
+func (jsdocTagCompletionHintSource) CompletionHints() []LSPCompletionHint {
+  return []LSPCompletionHint{{
+    Scope: "jsdoc",
+    After: "@",
+    Items: []LSPCompletionItem{{Insert: "param"}},
+  }}
+}
+
+// TestLSPCompletionRefusesHintsInsideAStringLiteral verifies the scope decision
+// where it is observable.
+//
+// The lexical table proves the scanner; this proves the request path still asks
+// it. A refactor that recomputed scope from the line prefix, or that passed the
+// wrong offset, would put `jsdoc/check-tag-names` tags into ordinary source
+// text — a position the owning rule never inspects — and no unit test of the
+// matcher alone would notice.
+//
+//  1. Ask for completion after `@par` inside a string literal that contains the
+//     JSDoc opener.
+//  2. Ask again at the same tag inside a real doc comment.
+//  3. Assert silence for the first and the published item for the second.
+func TestLSPCompletionRefusesHintsInsideAStringLiteral(t *testing.T) {
+  const literalURI = "file:///project/src/literal.ts"
+  const blockURI = "file:///project/src/block.ts"
+  proxy := &Proxy{
+    source: jsdocTagCompletionHintSource{},
+    documentText: map[string]string{
+      literalURI: "const example = \"/** @par\";\n",
+      blockURI:   "/**\n * @par\n */\nexport const value = 1;\n",
+    },
+  }
+
+  literalParams, err := json.Marshal(map[string]any{
+    "textDocument": map[string]any{"uri": literalURI},
+    "position":     map[string]any{"line": 0, "character": 25},
+  })
+  if err != nil {
+    t.Fatalf("encode completion params: %v", err)
+  }
+  if pending := proxy.completionItemsFor(Envelope{Params: literalParams}); len(pending.items) != 0 {
+    t.Errorf("a string literal was offered %v, want nothing", inserts(pending.items))
+  }
+
+  blockParams, err := json.Marshal(map[string]any{
+    "textDocument": map[string]any{"uri": blockURI},
+    "position":     map[string]any{"line": 1, "character": 7},
+  })
+  if err != nil {
+    t.Fatalf("encode completion params: %v", err)
+  }
+  pending := proxy.completionItemsFor(Envelope{Params: blockParams})
+  if got := inserts(pending.items); !equalStrings(got, []string{"param"}) {
+    t.Fatalf("a real doc comment was offered %v, want [param]", got)
+  }
+  // The refusal must not have come from a broken filter range either.
+  if pending.replaceRange.Start != (LSPPosition{Line: 1, Character: 4}) ||
+    pending.replaceRange.End != (LSPPosition{Line: 1, Character: 7}) {
+    t.Errorf("replacement range = %+v, want character 4..7", pending.replaceRange)
+  }
+}

package/internal/lspserver/lsp_completion_replaces_full_filter_in_rank_order_test.go

@@ -0,0 +1,85 @@
+package lspserver
+
+import (
+  "encoding/json"
+  "testing"
+)
+
+type rankedCompletionHintSource struct{ NullPluginSource }
+
+func (rankedCompletionHintSource) CompletionHints() []LSPCompletionHint {
+  return []LSPCompletionHint{{
+    Scope: "jsdoc",
+    After: "@evidence ",
+    Items: []LSPCompletionItem{
+      {Insert: "docs/stable.md", Label: "stable"},
+      {Insert: "docs/derived.md"},
+    },
+  }}
+}
+
+// TestLSPCompletionReplacesFullFilterInRankOrder verifies path completion edits.
+//
+// A completion label containing slashes cannot rely on the editor's default
+// word range: replacing only the last segment of `文档/sp` would duplicate the
+// path prefix. The range is measured in UTF-16 units, and explicit sort keys
+// preserve the publisher's ranking instead of letting the client alphabetize it.
+//
+//  1. Match two ranked hints after a non-BMP character and a CJK path prefix.
+//  2. Merge them into the null completion response tsgo uses in JSDoc prose.
+//  3. Assert both text edits replace the full filter and sort in slice order.
+func TestLSPCompletionReplacesFullFilterInRankOrder(t *testing.T) {
+  const uri = "file:///project/src/main.ts"
+  const text = "/** 😀 @evidence 文档/sp"
+  proxy := &Proxy{
+    source:       rankedCompletionHintSource{},
+    documentText: map[string]string{uri: text},
+  }
+  params, _ := json.Marshal(map[string]any{
+    "textDocument": map[string]any{"uri": uri},
+    "position":     map[string]any{"line": 0, "character": 22},
+  })
+  pending := proxy.completionItemsFor(Envelope{Params: params})
+  if len(pending.items) != 2 {
+    t.Fatalf("matched %d completion items, want 2", len(pending.items))
+  }
+
+  merged := mergeCompletionResponseWithRequest(
+    []byte(`{"jsonrpc":"2.0","id":1,"result":null}`),
+    pending,
+  )
+  var response struct {
+    Result struct {
+      Items []struct {
+        FilterText string `json:"filterText"`
+        SortText   string `json:"sortText"`
+        TextEdit   struct {
+          Range   LSPRange `json:"range"`
+          NewText string   `json:"newText"`
+        } `json:"textEdit"`
+      } `json:"items"`
+    } `json:"result"`
+  }
+  if err := json.Unmarshal(merged, &response); err != nil {
+    t.Fatalf("decode merged completion response: %v\n%s", err, merged)
+  }
+  if len(response.Result.Items) != 2 {
+    t.Fatalf("merged %d completion items, want 2", len(response.Result.Items))
+  }
+  for index, item := range response.Result.Items {
+    if item.TextEdit.Range.Start != (LSPPosition{Line: 0, Character: 17}) ||
+      item.TextEdit.Range.End != (LSPPosition{Line: 0, Character: 22}) {
+      t.Errorf("item %d replacement range = %+v, want character 17..22", index, item.TextEdit.Range)
+    }
+    if item.FilterText != item.TextEdit.NewText {
+      t.Errorf("item %d filterText = %q, want inserted text %q", index, item.FilterText, item.TextEdit.NewText)
+    }
+  }
+  if response.Result.Items[0].SortText >= response.Result.Items[1].SortText {
+    t.Errorf(
+      "sort keys %q, %q do not preserve publisher order",
+      response.Result.Items[0].SortText,
+      response.Result.Items[1].SortText,
+    )
+  }
+}