ttsc 0.19.2 → 0.20.0

package/internal/lspserver/lsp_native_resident.go

@@ -0,0 +1,304 @@
+package lspserver
+
+import (
+  "bufio"
+  "encoding/json"
+  "fmt"
+  "io"
+  "os"
+  "os/exec"
+  "strings"
+  "sync"
+  "time"
+)
+
+// residentRequestTimeout bounds one resident verb round trip, mirroring the
+// spawn-per-verb path's nativePluginCommandTimeout. A rule that hangs must not
+// wedge the daemon's request mutex forever; on timeout the sidecar is killed and
+// the caller falls back to a fresh spawn.
+const residentRequestTimeout = nativePluginCommandTimeout
+
+// serveVerbDiagnostics, serveVerbCodeActions, and serveVerbHints are the verbs
+// routed to the resident daemon: the three that load a Program.
+// lsp-command-ids / lsp-code-action-kinds run once at startup and never load one
+// (routing them would spawn the daemon on the initialize path);
+// lsp-execute-command is user-initiated and keeps its spawn-per-verb path.
+const (
+  serveVerbDiagnostics = "lsp-diagnostics"
+  serveVerbCodeActions = "lsp-code-actions"
+  serveVerbHints       = "lsp-hints"
+)
+
+// serveClientRequest mirrors linthost's serveLSPRequest: the base project
+// options travel as the daemon's argv, only the per-verb fields per request.
+type serveClientRequest struct {
+  Verb        string   `json:"verb"`
+  URI         string   `json:"uri,omitempty"`
+  RangeJSON   string   `json:"rangeJson,omitempty"`
+  ContextJSON string   `json:"contextJson,omitempty"`
+  Invalidate  bool     `json:"invalidate,omitempty"`
+  Changed     []string `json:"changed,omitempty"`
+}
+
+// serveClientResponse mirrors linthost's serveLSPResponse: the verb's JSON
+// result verbatim and the exit code the one-shot verb would have returned.
+type serveClientResponse struct {
+  Result json.RawMessage `json:"result"`
+  Code   int             `json:"code"`
+}
+
+// residentSidecar is one long-lived `@ttsc/lint lsp-serve` child. It answers a
+// serialized stream of verb requests over stdin/stdout, holding a warm Program
+// across them, instead of the source respawning the sidecar per verb.
+type residentSidecar struct {
+  mu         sync.Mutex
+  cmd        *exec.Cmd
+  stdin      io.WriteCloser
+  stdout     *bufio.Reader
+  everServed bool
+  // invalidate piggybacks a full "drop the warm Program" onto the next request,
+  // set for a change the proxy cannot localize.
+  invalidate bool
+  // changed piggybacks the document URIs that changed on disk onto the next
+  // request, so the daemon updates the warm Program incrementally rather than
+  // rebuilding it.
+  changed []string
+}
+
+// serveRun routes a serve-able verb through the plugin's resident daemon.
+// It returns served=false to tell the caller to fall back to the spawn-per-verb
+// path: a sidecar that predates lsp-serve, a spawn failure, or a pipe that broke
+// mid-session all degrade to exec rather than losing the verb. served=true with
+// an error mirrors a nonzero one-shot exit — the daemon answered and the verb
+// failed — so the caller logs and skips exactly as it does for exec.
+func (s *NativePluginSource) serveRun(plugin NativeLSPPluginEntry, verb string, args []string) ([]byte, bool, error) {
+  if s == nil || strings.TrimSpace(plugin.Binary) == "" {
+    return nil, false, nil
+  }
+  s.residentMu.Lock()
+  if s.serveUnsupported[plugin.Binary] {
+    s.residentMu.Unlock()
+    return nil, false, nil
+  }
+  sc := s.residents[plugin.Binary]
+  if sc == nil {
+    sc = &residentSidecar{}
+    if s.residents == nil {
+      s.residents = map[string]*residentSidecar{}
+    }
+    s.residents[plugin.Binary] = sc
+  }
+  s.residentMu.Unlock()
+
+  body, code, err := sc.call(s, plugin, serveRequestFromArgs(verb, args))
+  if err != nil {
+    // Could not talk to the daemon. If it never once answered, treat lsp-serve
+    // as unsupported and stop trying — every sidecar built before this verb
+    // rejects it, and retrying would spawn-and-fail per request forever. If it
+    // had been answering, the pipe broke; leave it eligible to respawn next
+    // call. Either way this call falls back to a fresh spawn so the verb still
+    // works.
+    s.residentMu.Lock()
+    if !sc.everServed {
+      if s.serveUnsupported == nil {
+        s.serveUnsupported = map[string]bool{}
+      }
+      s.serveUnsupported[plugin.Binary] = true
+    }
+    s.residentMu.Unlock()
+    return nil, false, nil
+  }
+  if code != 0 {
+    return nil, true, fmt.Errorf("ttscserver: %s %s (resident) exit %d", pluginLabel(plugin), verb, code)
+  }
+  return body, true, nil
+}
+
+// call sends one request to the daemon and reads its reply, serializing access
+// to the single pipe. It spawns the child on first use or after a death, and
+// enforces a per-request timeout so a hung rule cannot wedge the mutex.
+func (sc *residentSidecar) call(s *NativePluginSource, plugin NativeLSPPluginEntry, req serveClientRequest) ([]byte, int, error) {
+  sc.mu.Lock()
+  defer sc.mu.Unlock()
+  if sc.cmd == nil {
+    if err := sc.spawn(s, plugin); err != nil {
+      return nil, 0, err
+    }
+  }
+  if sc.invalidate {
+    req.Invalidate = true
+    sc.invalidate = false
+  }
+  if len(sc.changed) > 0 {
+    req.Changed = sc.changed
+    sc.changed = nil
+  }
+  line, err := json.Marshal(req)
+  if err != nil {
+    return nil, 0, err
+  }
+  line = append(line, '\n')
+  if _, err := sc.stdin.Write(line); err != nil {
+    sc.kill()
+    return nil, 0, err
+  }
+
+  type readResult struct {
+    line []byte
+    err  error
+  }
+  done := make(chan readResult, 1)
+  go func() {
+    raw, err := sc.stdout.ReadBytes('\n')
+    done <- readResult{line: raw, err: err}
+  }()
+  select {
+  case <-time.After(residentRequestTimeout):
+    sc.kill()
+    return nil, 0, fmt.Errorf("ttscserver: %s %s (resident) timed out", pluginLabel(plugin), req.Verb)
+  case res := <-done:
+    if res.err != nil {
+      sc.kill()
+      return nil, 0, res.err
+    }
+    var resp serveClientResponse
+    if err := json.Unmarshal(res.line, &resp); err != nil {
+      sc.kill()
+      return nil, 0, err
+    }
+    sc.everServed = true
+    return resp.Result, resp.Code, nil
+  }
+}
+
+// spawn starts the resident child with the base project args and the lsp-serve
+// verb; per-verb fields travel per request. The caller holds sc.mu.
+func (sc *residentSidecar) spawn(s *NativePluginSource, plugin NativeLSPPluginEntry) error {
+  allArgs := []string{
+    "lsp-serve",
+    "--cwd=" + s.cwd,
+    "--tsconfig=" + s.tsconfig,
+    "--plugins-json=" + s.pluginsJSON,
+  }
+  if plugin.ProjectContextArgs && strings.TrimSpace(s.projectContextJSON) != "" {
+    allArgs = append(allArgs, "--project-context-json="+s.projectContextJSON)
+  }
+  cmd := exec.Command(plugin.Binary, allArgs...)
+  cmd.Dir = s.cwd
+  cmd.Env = os.Environ()
+  // Drain the child's stderr to the source log so its pipe cannot fill and block
+  // the child, and so a resident rule panic is still visible.
+  cmd.Stderr = residentStderr{s: s, label: pluginLabel(plugin)}
+  stdin, err := cmd.StdinPipe()
+  if err != nil {
+    return err
+  }
+  stdout, err := cmd.StdoutPipe()
+  if err != nil {
+    _ = stdin.Close()
+    return err
+  }
+  if err := cmd.Start(); err != nil {
+    _ = stdin.Close()
+    return err
+  }
+  sc.cmd = cmd
+  sc.stdin = stdin
+  sc.stdout = bufio.NewReader(stdout)
+  return nil
+}
+
+// kill terminates the child and clears its handles so the next call respawns.
+// The caller holds sc.mu.
+func (sc *residentSidecar) kill() {
+  if sc.stdin != nil {
+    _ = sc.stdin.Close()
+  }
+  if sc.cmd != nil && sc.cmd.Process != nil {
+    _ = sc.cmd.Process.Kill()
+    _ = sc.cmd.Wait()
+  }
+  sc.cmd = nil
+  sc.stdin = nil
+  sc.stdout = nil
+}
+
+// InvalidateResidentPrograms tells every live resident daemon that documents
+// changed on disk, so the next request refreshes the warm Program before
+// serving. Given the changed URIs, the daemon updates those files incrementally;
+// given none, it drops the whole Program (a change the proxy could not
+// localize). It mirrors how the proxy already invalidates the symbol provider on
+// the same editor signals.
+func (s *NativePluginSource) InvalidateResidentPrograms(changedURIs ...string) {
+  if s == nil {
+    return
+  }
+  s.residentMu.Lock()
+  residents := make([]*residentSidecar, 0, len(s.residents))
+  for _, sc := range s.residents {
+    residents = append(residents, sc)
+  }
+  s.residentMu.Unlock()
+  for _, sc := range residents {
+    sc.mu.Lock()
+    if len(changedURIs) > 0 {
+      sc.changed = append(sc.changed, changedURIs...)
+    } else {
+      sc.invalidate = true
+    }
+    sc.mu.Unlock()
+  }
+}
+
+// shutdownResidents kills every resident child. Called on server teardown; the
+// children also exit on their own when the parent closes their stdin at process
+// exit, so this is the graceful path, not the only one.
+func (s *NativePluginSource) shutdownResidents() {
+  if s == nil {
+    return
+  }
+  s.residentMu.Lock()
+  residents := s.residents
+  s.residents = map[string]*residentSidecar{}
+  s.residentMu.Unlock()
+  for _, sc := range residents {
+    sc.mu.Lock()
+    sc.kill()
+    sc.mu.Unlock()
+  }
+}
+
+// serveRequestFromArgs rebuilds a serve request from the same `--flag=value`
+// argv the spawn-per-verb path passes, so the two transports share one call
+// shape at the source's verb methods.
+func serveRequestFromArgs(verb string, args []string) serveClientRequest {
+  req := serveClientRequest{Verb: verb}
+  for _, arg := range args {
+    switch {
+    case strings.HasPrefix(arg, "--uri="):
+      req.URI = strings.TrimPrefix(arg, "--uri=")
+    case strings.HasPrefix(arg, "--range-json="):
+      req.RangeJSON = strings.TrimPrefix(arg, "--range-json=")
+    case strings.HasPrefix(arg, "--context-json="):
+      req.ContextJSON = strings.TrimPrefix(arg, "--context-json=")
+    }
+  }
+  return req
+}
+
+// residentStderr forwards a resident child's stderr to the source log line by
+// line, so it interleaves cleanly with the source's own logging.
+type residentStderr struct {
+  s     *NativePluginSource
+  label string
+}
+
+func (w residentStderr) Write(p []byte) (int, error) {
+  for _, line := range strings.Split(strings.TrimRight(string(p), "\n"), "\n") {
+    if strings.TrimSpace(line) == "" {
+      continue
+    }
+    w.s.log("%s (resident): %s", w.label, line)
+  }
+  return len(p), nil
+}

package/internal/lspserver/lsp_plugin.go

@@ -34,15 +34,57 @@ const (
   LSPDiagnosticSeverityHint LSPDiagnosticSeverity = 4
 )
 
-// LSPDiagnostic is the minimal subset of the LSP Diagnostic type
-// ttscserver injects into outgoing publishDiagnostics. omitempty is set
-// on optional fields so the merged JSON stays close to what tsgo emits.
+// LSPDiagnostic is the subset of the LSP Diagnostic type ttscserver injects
+// into outgoing publishDiagnostics. omitempty is set on optional fields so the
+// merged JSON stays close to what tsgo emits.
+//
+// The proxy decodes each sidecar diagnostic into this struct and re-encodes it,
+// so a field absent here is silently dropped on the way to the editor. Every
+// LSP Diagnostic field a producer might set must therefore appear, or the proxy
+// truncates it.
 type LSPDiagnostic struct {
-  Range    LSPRange              `json:"range"`
-  Severity LSPDiagnosticSeverity `json:"severity,omitempty"`
-  Code     any                   `json:"code,omitempty"`
-  Source   string                `json:"source,omitempty"`
-  Message  string                `json:"message"`
+  Range           LSPRange              `json:"range"`
+  Severity        LSPDiagnosticSeverity `json:"severity,omitempty"`
+  Code            any                   `json:"code,omitempty"`
+  CodeDescription *LSPCodeDescription   `json:"codeDescription,omitempty"`
+  // Tags classify the diagnostic (1 = unnecessary, 2 = deprecated). Carried
+  // through so a plugin's tag is not silently dropped when the proxy re-encodes
+  // the diagnostic — the same truncation codeDescription had to be rescued from.
+  Tags []int `json:"tags,omitempty"`
+  // Data is opaque state the producer attaches to the diagnostic. The editor
+  // preserves it and hands it back on a codeAction request whose context
+  // includes this diagnostic, so a rule can recover what it computed without
+  // recomputing it. Carried through unread — like the other optional fields, an
+  // absent one it did not round-trip would be a silent truncation.
+  Data json.RawMessage `json:"data,omitempty"`
+  // RelatedInformation are secondary locations the diagnostic points at, each
+  // with its own message — the editor renders them as clickable lines under the
+  // diagnostic. Carried through so a sidecar's related locations survive the
+  // proxy's re-encode, the same truncation the other optional fields had to be
+  // rescued from.
+  RelatedInformation []LSPDiagnosticRelatedInformation `json:"relatedInformation,omitempty"`
+  Source             string                            `json:"source,omitempty"`
+  Message            string                            `json:"message"`
+}
+
+// LSPDiagnosticRelatedInformation is one entry of a diagnostic's
+// relatedInformation: a secondary location with a message. It reuses the
+// package's LSPLocation (a URI plus a range). The proxy does not read it — it
+// exists so the field is not dropped on re-encode.
+type LSPDiagnosticRelatedInformation struct {
+  Location LSPLocation `json:"location"`
+  Message  string      `json:"message"`
+}
+
+// LSPCodeDescription is the LSP CodeDescription type: a documentation URL for a
+// diagnostic's Code. Editors render the Code as a link to Href, so a rule name
+// in the Problems panel can lead to the rule's docs. The proxy carries whatever
+// a sidecar supplies; it does not synthesize the URL, because only the producer
+// knows what its own Code values mean. @ttsc/lint derives one per rule family
+// in packages/lint/linthost/rule_docs.go and leaves it unset where no vetted
+// page exists.
+type LSPCodeDescription struct {
+  Href string `json:"href"`
 }
 
 // LSPCodeAction is the minimal Code Action shape ttscserver returns from
@@ -150,6 +192,41 @@ type PluginSource interface {
 // LSP server is hosted without any ttsc plugin pipeline (smoke tests,
 // docs build). It returns no diagnostics/actions and no command ids so the
 // proxy still exercises its merge paths even with no plugin activity.
+// LSPCompletionHint is one group of completion items a plugin offers, together
+// with the declarative rule saying where they apply.
+//
+// The rule has to be data rather than a callback because the plugin that
+// produced it is a subprocess that has already exited. Asking it per keystroke
+// would mean a process spawn and a Program reload per character; the corpus
+// therefore travels once and the proxy answers from memory.
+type LSPCompletionHint struct {
+  // Scope names the syntactic region the cursor must sit in.
+  Scope string `json:"scope"`
+  // After is a literal the line prefix must contain. The text following its
+  // LAST occurrence is what the editor filters on and what Insert replaces.
+  //
+  // Deliberately a literal and not a pattern. A regex would be unvalidatable at
+  // discovery time, and the one shipped example of plugin-supplied regex driving
+  // completion — Tailwind's experimental.classRegex — is a documented source of
+  // editor hangs. When several hints match one line, the occurrence nearest the
+  // cursor wins; at that occurrence the longest After wins, and only the same
+  // trigger merges. That is enough to layer a corpus without hiding a later
+  // trigger behind an earlier one.
+  After string `json:"after"`
+  // Items are offered in slice order; the proxy derives the sort key from it.
+  Items []LSPCompletionItem `json:"items"`
+}
+
+// LSPCompletionItem is one plugin-contributed completion.
+//
+// Fully resolved on arrival: there is no completionItem/resolve round trip,
+// because resolving would require asking a rule that no longer exists.
+type LSPCompletionItem struct {
+  Insert string `json:"insert"`
+  Label  string `json:"label,omitempty"`
+  Detail string `json:"detail,omitempty"`
+}
+
 type NullPluginSource struct{}
 
 // Diagnostics returns no plugin diagnostics.

package/internal/lspserver/lsp_plugin_completion_resolve_stays_local_test.go

@@ -0,0 +1,82 @@
+package lspserver
+
+import (
+  "bytes"
+  "encoding/json"
+  "testing"
+)
+
+// TestLSPPluginCompletionResolveStaysLocal verifies completion ownership.
+//
+// TypeScript-Go advertises resolve support but dereferences its private data
+// payload for every resolved item. A plugin hint has no such payload and is
+// already complete, so forwarding it upstream can fault the language server.
+//
+//  1. Encode a plugin completion and send that item back as a resolve request.
+//  2. Assert the proxy answers locally with the item unchanged.
+//  3. Assert an upstream-owned item remains unhandled and is still forwarded.
+func TestLSPPluginCompletionResolveStaysLocal(t *testing.T) {
+  merged := mergeCompletionResponse(
+    []byte(`{"jsonrpc":"2.0","id":1,"result":null}`),
+    []LSPCompletionItem{{Insert: "evidence"}},
+  )
+  var completion struct {
+    Result struct {
+      Items []json.RawMessage `json:"items"`
+    } `json:"result"`
+  }
+  if err := json.Unmarshal(merged, &completion); err != nil || len(completion.Result.Items) != 1 {
+    t.Fatalf("decode plugin completion item: %v\n%s", err, merged)
+  }
+  item := completion.Result.Items[0]
+
+  var editor bytes.Buffer
+  proxy := &Proxy{editorOut: &editor}
+  handled, err := proxy.handleEditorEnvelope(Envelope{
+    JSONRPC: "2.0",
+    ID:      json.RawMessage("7"),
+    Method:  methodCompletionResolve,
+    Params:  item,
+  }, nil)
+  if err != nil {
+    t.Fatalf("resolve plugin completion: %v", err)
+  }
+  if !handled {
+    t.Fatal("plugin completion resolve was forwarded upstream")
+  }
+  _, body, err := NewFrameReader(bytes.NewReader(editor.Bytes())).Read()
+  if err != nil {
+    t.Fatalf("read local resolve response: %v", err)
+  }
+  response, err := ParseEnvelope(body)
+  if err != nil {
+    t.Fatalf("parse local resolve response: %v", err)
+  }
+  var got any
+  var want any
+  if err := json.Unmarshal(response.Result, &got); err != nil {
+    t.Fatalf("decode local resolve result: %v", err)
+  }
+  if err := json.Unmarshal(item, &want); err != nil {
+    t.Fatalf("decode original plugin item: %v", err)
+  }
+  gotJSON, _ := json.Marshal(got)
+  wantJSON, _ := json.Marshal(want)
+  if !bytes.Equal(gotJSON, wantJSON) {
+    t.Errorf("local resolve changed the plugin item:\n got %s\nwant %s", gotJSON, wantJSON)
+  }
+
+  editor.Reset()
+  handled, err = proxy.handleEditorEnvelope(Envelope{
+    JSONRPC: "2.0",
+    ID:      json.RawMessage("8"),
+    Method:  methodCompletionResolve,
+    Params:  json.RawMessage(`{"label":"upstream","data":{"fileName":"/project/main.ts"}}`),
+  }, nil)
+  if err != nil {
+    t.Fatalf("route upstream completion resolve: %v", err)
+  }
+  if handled || editor.Len() != 0 {
+    t.Error("upstream completion resolve was intercepted instead of forwarded")
+  }
+}

package/internal/lspserver/lsp_position_conversions_span_astral_and_combining_runes_test.go

@@ -0,0 +1,119 @@
+package lspserver
+
+import "testing"
+
+// TestLSPPositionConversionsSpanAstralAndCombiningRunes verifies that both
+// proxy-side position converters spend a UTF-16 budget, not a byte or rune one,
+// across every width a line can hold.
+//
+// UTF-16 is the encoding ttscserver pins for the whole session
+// (constrainInitializePositionEncoding), so these two helpers are the contract
+// for every feature that maps an editor column onto the cached buffer:
+// incremental didChange splicing and plugin completion. An astral rune is the
+// boundary that separates the three counting schemes at once — four bytes, one
+// rune, two UTF-16 units — and a combining mark is the boundary where two runes
+// render as one grapheme but still cost two units.
+//
+//  1. Convert the column just past the identifier on lines built from ASCII, BMP
+//     CJK, an astral rune, and a combining sequence.
+//  2. Assert both converters return the same byte offset for each.
+//  3. Assert the line walk, the end-of-line column, and an out-of-range column.
+func TestLSPPositionConversionsSpanAstralAndCombiningRunes(t *testing.T) {
+  cases := []struct {
+    name      string
+    text      string
+    line      int
+    character int
+    want      int
+    wantOK    bool
+  }{
+    {
+      name:      "ascii counts one unit per byte",
+      text:      "const value = 1;",
+      character: 11,
+      want:      11,
+      wantOK:    true,
+    },
+    {
+      name:      "bmp cjk is one unit and three bytes",
+      text:      "const 变量 = 1;",
+      character: 8,
+      want:      12,
+      wantOK:    true,
+    },
+    {
+      name:      "an astral rune is two units and four bytes",
+      text:      "const \U0001D499 = 1;",
+      character: 8,
+      want:      10,
+      wantOK:    true,
+    },
+    {
+      name:      "a combining mark costs its own unit",
+      text:      "const e\u0301 = 1;",
+      character: 8,
+      want:      9,
+      wantOK:    true,
+    },
+    {
+      name:      "the column before an astral rune stops before its bytes",
+      text:      "const \U0001D499 = 1;",
+      character: 6,
+      want:      6,
+      wantOK:    true,
+    },
+    {
+      name:      "the walk reaches the target line first",
+      text:      "a\nconst \U0001D499 = 1;",
+      line:      1,
+      character: 8,
+      want:      12,
+      wantOK:    true,
+    },
+    {
+      name:      "the column at end of line is in range",
+      text:      "const \U0001D499",
+      character: 8,
+      want:      10,
+      wantOK:    true,
+    },
+  }
+
+  for _, testCase := range cases {
+    t.Run(testCase.name, func(t *testing.T) {
+      got, ok := lspPositionToByteOffset(testCase.text, lspPositionWire{
+        Line:      testCase.line,
+        Character: testCase.character,
+      })
+      if got != testCase.want || ok != testCase.wantOK {
+        t.Errorf("lspPositionToByteOffset = (%d, %t), want (%d, %t)",
+          got, ok, testCase.want, testCase.wantOK)
+      }
+      completionOffset, completionOK := offsetForPosition(
+        testCase.text,
+        testCase.line,
+        testCase.character,
+      )
+      if completionOffset != testCase.want || !completionOK {
+        t.Errorf("offsetForPosition = (%d, %t), want (%d, true)",
+          completionOffset, completionOK, testCase.want)
+      }
+    })
+  }
+
+  // A column past the end of the line is a cache/editor divergence, not a
+  // clamped position: the buffer cache drops its entry rather than splice at a
+  // guessed byte.
+  if got, ok := lspPositionToByteOffset("const \U0001D499", lspPositionWire{Character: 99}); ok {
+    t.Errorf("lspPositionToByteOffset past end = (%d, true), want ok=false", got)
+  }
+
+  // The completion replace range is measured in the same units, so the filter
+  // width of a mixed-width prefix must agree with the columns above.
+  if units := utf16Length("é\U0001D499"); units != 4 {
+    t.Errorf("utf16Length = %d, want 4 (e + combining acute + astral pair)", units)
+  }
+  if units := utf16Length(""); units != 0 {
+    t.Errorf("utf16Length of the empty filter = %d, want 0", units)
+  }
+}