<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>docs/dev/lsp-extensions.md - fork/rust-analyzer @ 2022-07-04</title>
<meta name="description" content="docs/dev/lsp-extensions.md in fork/rust-analyzer at 2022-07-04.">
<meta property="og:title" content="docs/dev/lsp-extensions.md - fork/rust-analyzer @ 2022-07-04">
<meta property="og:description" content="docs/dev/lsp-extensions.md in fork/rust-analyzer at 2022-07-04.">
<meta property="og:type" content="website">
<meta property="og:site_name" content="git.julia.blue">
<link rel="stylesheet" href="/css/style.css?v=62">
<script type="module" src="/js/main.js?v=62"></script>
</head>
<body>
<main data-ref="2022-07-04" data-tip="75b22326dad1914c22484ab6672de5cae94f7457">
<noscript>
  <div class="callout">
    <p>
      hey! this is a static git repo viewer. commit diffs, file history,
      older commits and other revisions won't load without javascript.
    </p>
    <p>
      you are still able to view source files on branch/tag tips,
      but the experience is degraded.
    </p>
  </div>
</noscript>
<header class="repo"><div>
<h1>fork/rust-analyzer</h1>
</div>
<pre class="clone">git clone https://git.julia.blue/fork/rust-analyzer</pre>
</header>
<p class="snapshot-commit"><span class="commit-author">bors</span><span class="commit-message" data-commit="90236dd77ae817b5e2c6d30b3523890975d4d519">Auto merge of #11830 - nemethf:on-type-formatting, r=nemethf</span><span class="snapshot-sha sha" data-commit="90236dd77ae817b5e2c6d30b3523890975d4d519">90236dd77a</span><time datetime="2022-05-22T08:59:04+00:00" title="2022-05-22 08:59:04 +0000">2022-05-22</time></p>
<header class="topbar"><details class="switcher"><summary>2022-07-04</summary><div class="menu"><strong>branches</strong><a href="/fork/rust-analyzer/ref/master/">master</a><strong>tags</strong><a href="/fork/rust-analyzer/ref/2022-06-13/">2022-06-13</a><a href="/fork/rust-analyzer/ref/2022-06-20/">2022-06-20</a><a href="/fork/rust-analyzer/ref/2022-06-27/">2022-06-27</a><a class="current" href="/fork/rust-analyzer/ref/2022-07-04/">2022-07-04</a><a href="/fork/rust-analyzer/ref/2022-07-11/">2022-07-11</a><a href="/fork/rust-analyzer/ref/2022-07-18/">2022-07-18</a><a href="/fork/rust-analyzer/ref/2022-07-25/">2022-07-25</a><a href="/fork/rust-analyzer/ref/nightly/">nightly</a><a class="all" href="/fork/rust-analyzer/refs">all refs →</a></div></details><nav class="crumbs"><a href="/fork/rust-analyzer/">rust-analyzer</a> / <a href="/fork/rust-analyzer/ref/2022-07-04/tree/docs/">docs</a> / <a href="/fork/rust-analyzer/ref/2022-07-04/tree/docs/dev/">dev</a> / <span class="cur">lsp-extensions.md</span></nav>
<span class="view-stats"><span>20.4 KiB</span><span>761 lines</span></span><span class="actions"><a class="raw" href="/fork/rust-analyzer/raw/983d8e1ac095dfb2ca0f4ea54cd5ed20944d7b74/docs/dev/lsp-extensions.md">raw</a></span></header>
<div class="markdown-view"><input type="radio" name="markdown-view" id="markdown-rendered" checked><label for="markdown-rendered">rendered</label><input type="radio" name="markdown-view" id="markdown-code"><label for="markdown-code">code</label><section class="readme rendered">&lt;!---
lsp_ext.rs hash: 2a188defec26cc7c

If you need to change the above hash to make the test pass, please check if you
need to adjust this doc as well and ping this issue:

  https://github.com/rust-analyzer/rust-analyzer/issues/4604

---&gt;
<h1>LSP Extensions</h1>
<p>This document describes LSP extensions used by rust-analyzer.
It's a best effort document, when in doubt, consult the source (and send a PR with clarification ;-) ).
We aim to upstream all non Rust-specific extensions to the protocol, but this is not a top priority.
All capabilities are enabled via the <code>experimental</code> field of <code>ClientCapabilities</code> or <code>ServerCapabilities</code>.
Requests which we hope to upstream live under <code>experimental/</code> namespace.
Requests, which are likely to always remain specific to <code>rust-analyzer</code> are under <code>rust-analyzer/</code> namespace.</p>
<p>If you want to be notified about the changes to this document, subscribe to <a href="https://github.com/rust-analyzer/rust-analyzer/issues/4604">#4604</a>.</p>
<h2>UTF-8 offsets</h2>
<p>rust-analyzer supports clangd's extension for opting into UTF-8 as the coordinate space for offsets (by default, LSP uses UTF-16 offsets).</p>
<p>https://clangd.llvm.org/extensions.html#utf-8-offsets</p>
<h2>Configuration in <code>initializationOptions</code></h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/567</p>
<p>The <code>initializationOptions</code> field of the <code>InitializeParams</code> of the initialization request should contain the <code>"rust-analyzer"</code> section of the configuration.</p>
<p><code>rust-analyzer</code> normally sends a <code>"workspace/configuration"</code> request with <code>{ "items": ["rust-analyzer"] }</code> payload.
However, the server can't do this during initialization.
At the same time some essential configuration parameters are needed early on, before servicing requests.
For this reason, we ask that <code>initializationOptions</code> contains the configuration, as if the server did make a <code>"workspace/configuration"</code> request.</p>
<p>If a language client does not know about <code>rust-analyzer</code>'s configuration options it can get sensible defaults by doing any of the following:</p>
<ul>
<li>Not sending <code>initializationOptions</code></li>
<li>Sending <code>"initializationOptions": null</code></li>
<li>Sending <code>"initializationOptions": {}</code></li>
</ul>
<h2>Snippet <code>TextEdit</code></h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/724</p>
<p><strong>Experimental Client Capability:</strong> <code>{ "snippetTextEdit": boolean }</code></p>
<p>If this capability is set, <code>WorkspaceEdit</code>s returned from <code>codeAction</code> requests and <code>TextEdit</code>s returned from <code>textDocument/onTypeFormatting</code> requests might contain <code>SnippetTextEdit</code>s instead of usual <code>TextEdit</code>s:</p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>SnippetTextEdit</a-t> <a-k>extends</a-k> <a-t>TextEdit</a-t> <a-p>{</a-p>
    <a-pr>insertTextFormat</a-pr>?: <a-t>InsertTextFormat</a-t><a-p>;</a-p>
    <a-pr>annotationId</a-pr>?: <a-t>ChangeAnnotationIdentifier</a-t><a-p>;</a-p>
<a-p>}</a-p></pre>
<pre class="language-typescript"><a-k>export</a-k> <a-k>interface</a-k> <a-t>TextDocumentEdit</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>OptionalVersionedTextDocumentIdentifier</a-t><a-p>;</a-p>
    <a-pr>edits</a-pr>: <a-p>(</a-p><a-t>TextEdit</a-t> <a-o>|</a-o> <a-t>SnippetTextEdit</a-t><a-p>)[];</a-p>
<a-p>}</a-p></pre>
<p>When applying such code action or text edit, the editor should insert snippet, with tab stops and placeholder.
At the moment, rust-analyzer guarantees that only a single edit will have <code>InsertTextFormat.Snippet</code>.</p>
<h3>Example</h3>
<p>"Add <code>derive</code>" code action transforms <code>struct S;</code> into <code>#[derive($0)] struct S;</code></p>
<h3>Unresolved Questions</h3>
<ul>
<li>Where exactly are <code>SnippetTextEdit</code>s allowed (only in code actions at the moment)?</li>
<li>Can snippets span multiple files (so far, no)?</li>
</ul>
<h2><code>CodeAction</code> Groups</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/994</p>
<p><strong>Experimental Client Capability:</strong> <code>{ "codeActionGroup": boolean }</code></p>
<p>If this capability is set, <code>CodeAction</code>s returned from the server contain an additional field, <code>group</code>:</p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>CodeAction</a-t> <a-p>{</a-p>
    <a-pr>title</a-pr>: <a-t>string</a-t><a-p>;</a-p>
    <a-pr>group</a-pr>?: <a-t>string</a-t><a-p>;</a-p>
    ...
<a-p>}</a-p></pre>
<p>All code-actions with the same <code>group</code> should be grouped under single (extendable) entry in lightbulb menu.
The set of actions <code>[ { title: "foo" }, { group: "frobnicate", title: "bar" }, { group: "frobnicate", title: "baz" }]</code> should be rendered as</p>
<pre>💡
  +-------------+
  | foo         |
  +-------------+-----+
  | frobnicate &gt;| bar |
  +-------------+-----+
                | baz |
                +-----+
</pre>
<p>Alternatively, selecting <code>frobnicate</code> could present a user with an additional menu to choose between <code>bar</code> and <code>baz</code>.</p>
<h3>Example</h3>
<pre class="language-rust"><a-k>fn</a-k> <a-f>main</a-f><a-p>()</a-p> <a-p>{</a-p>
    <a-k>let</a-k> x<a-p>:</a-p> <a-t>Entry</a-t><a-c>/*cursor here*/</a-c> = <a-m>todo!</a-m><a-p>();</a-p>
<a-p>}</a-p></pre>
<p>Invoking code action at this position will yield two code actions for importing <code>Entry</code> from either <code>collections::HashMap</code> or <code>collection::BTreeMap</code>, grouped under a single "import" group.</p>
<h3>Unresolved Questions</h3>
<ul>
<li>Is a fixed two-level structure enough?</li>
<li>Should we devise a general way to encode custom interaction protocols for GUI refactorings?</li>
</ul>
<h2>Parent Module</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/1002</p>
<p><strong>Experimental Server Capability:</strong> <code>{ "parentModule": boolean }</code></p>
<p>This request is sent from client to server to handle "Goto Parent Module" editor action.</p>
<p><strong>Method:</strong> <code>experimental/parentModule</code></p>
<p><strong>Request:</strong> <code>TextDocumentPositionParams</code></p>
<p><strong>Response:</strong> <code>Location | Location[] | LocationLink[] | null</code></p>
<h3>Example</h3>
<pre class="language-rust"><a-c>// src/main.rs</a-c>
<a-k>mod</a-k> foo<a-p>;</a-p>
<a-c>// src/foo.rs</a-c>

<a-c>/* cursor here*/</a-c></pre>
<p><code>experimental/parentModule</code> returns a single <code>Link</code> to the <code>mod foo;</code> declaration.</p>
<h3>Unresolved Question</h3>
<ul>
<li>An alternative would be to use a more general "gotoSuper" request, which would work for super methods, super classes and super modules.
This is the approach IntelliJ Rust is taking.
However, experience shows that super module (which generally has a feeling of navigation between files) should be separate.
If you want super module, but the cursor happens to be inside an overridden function, the behavior with single "gotoSuper" request is surprising.</li>
</ul>
<h2>Join Lines</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/992</p>
<p><strong>Experimental Server Capability:</strong> <code>{ "joinLines": boolean }</code></p>
<p>This request is sent from client to server to handle "Join Lines" editor action.</p>
<p><strong>Method:</strong> <code>experimental/joinLines</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>JoinLinesParams</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>,</a-p>
    <a-c>/// Currently active selections/cursor offsets.</a-c>
    <a-c>/// This is an array to support multiple cursors.</a-c>
    <a-pr>ranges</a-pr>: <a-t>Range</a-t><a-p>[],</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong> <code>TextEdit[]</code></p>
<h3>Example</h3>
<pre class="language-rust"><a-k>fn</a-k> <a-f>main</a-f><a-p>()</a-p> <a-p>{</a-p>
    <a-c>/*cursor here*/</a-c><a-k>let</a-k> x = <a-p>{</a-p>
        <a-co>92</a-co>
    <a-p>};</a-p>
<a-p>}</a-p></pre>
<p><code>experimental/joinLines</code> yields (curly braces are automagically removed)</p>
<pre class="language-rust"><a-k>fn</a-k> <a-f>main</a-f><a-p>()</a-p> <a-p>{</a-p>
    <a-k>let</a-k> x = <a-co>92</a-co><a-p>;</a-p>
<a-p>}</a-p></pre>
<h3>Unresolved Question</h3>
<ul>
<li>What is the position of the cursor after <code>joinLines</code>?
Currently, this is left to editor's discretion, but it might be useful to specify on the server via snippets.
However, it then becomes unclear how it works with multi cursor.</li>
</ul>
<h2>On Enter</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/1001</p>
<p><strong>Experimental Server Capability:</strong> <code>{ "onEnter": boolean }</code></p>
<p>This request is sent from client to server to handle the &lt;kbd&gt;Enter&lt;/kbd&gt; key press.</p>
<p><strong>Method:</strong> <code>experimental/onEnter</code></p>
<p><strong>Request:</strong>: <code>TextDocumentPositionParams</code></p>
<p><strong>Response:</strong></p>
<pre class="language-typescript"><a-t>SnippetTextEdit</a-t><a-p>[</a-p><a-v>]</a-v></pre>
<h3>Example</h3>
<pre class="language-rust"><a-k>fn</a-k> <a-f>main</a-f><a-p>()</a-p> <a-p>{</a-p>
    <a-c>// Some /*cursor here*/ docs</a-c>
    <a-k>let</a-k> x = <a-co>92</a-co><a-p>;</a-p>
<a-p>}</a-p></pre>
<p><code>experimental/onEnter</code> returns the following snippet</p>
<pre class="language-rust"><a-k>fn</a-k> <a-f>main</a-f><a-p>()</a-p> <a-p>{</a-p>
    <a-c>// Some</a-c>
    <a-c>// $0 docs</a-c>
    <a-k>let</a-k> x = <a-co>92</a-co><a-p>;</a-p>
<a-p>}</a-p></pre>
<p>The primary goal of <code>onEnter</code> is to handle automatic indentation when opening a new line.
This is not yet implemented.
The secondary goal is to handle fixing up syntax, like continuing doc strings and comments, and escaping <code>\n</code> in string literals.</p>
<p>As proper cursor positioning is raison-d'etat for <code>onEnter</code>, it uses <code>SnippetTextEdit</code>.</p>
<h3>Unresolved Question</h3>
<ul>
<li>How to deal with synchronicity of the request?
One option is to require the client to block until the server returns the response.
Another option is to do a OT-style merging of edits from client and server.
A third option is to do a record-replay: client applies heuristic on enter immediately, then applies all user's keypresses.
When the server is ready with the response, the client rollbacks all the changes and applies the recorded actions on top of the correct response.</li>
<li>How to deal with multiple carets?</li>
<li>Should we extend this to arbitrary typed events and not just <code>onEnter</code>?</li>
</ul>
<h2>Structural Search Replace (SSR)</h2>
<p><strong>Experimental Server Capability:</strong> <code>{ "ssr": boolean }</code></p>
<p>This request is sent from client to server to handle structural search replace -- automated syntax tree based transformation of the source.</p>
<p><strong>Method:</strong> <code>experimental/ssr</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>SsrParams</a-t> <a-p>{</a-p>
    <a-c>/// Search query.</a-c>
    <a-c>/// The specific syntax is specified outside of the protocol.</a-c>
    <a-pr>query</a-pr>: <a-t>string</a-t><a-p>,</a-p>
    <a-c>/// If true, only check the syntax of the query and don&#39;t compute the actual edit.</a-c>
    <a-pr>parseOnly</a-pr>: <a-t>boolean</a-t><a-p>,</a-p>
    <a-c>/// The current text document. This and `position` will be used to determine in what scope</a-c>
    <a-c>/// paths in `query` should be resolved.</a-c>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>;</a-p>
    <a-c>/// Position where SSR was invoked.</a-c>
    <a-pr>position</a-pr>: <a-t>Position</a-t><a-p>;</a-p>
    <a-c>/// Current selections. Search/replace will be restricted to these if non-empty.</a-c>
    <a-pr>selections</a-pr>: <a-t>Range</a-t><a-p>[];</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong></p>
<pre class="language-typescript"><a-t>WorkspaceEdit</a-t></pre>
<h3>Example</h3>
<p>SSR with query <code>foo($a, $b) ==&gt;&gt; ($a).foo($b)</code> will transform, eg <code>foo(y + 5, z)</code> into <code>(y + 5).foo(z)</code>.</p>
<h3>Unresolved Question</h3>
<ul>
<li>Probably needs search without replace mode</li>
<li>Needs a way to limit the scope to certain files.</li>
</ul>
<h2>Matching Brace</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/999</p>
<p><strong>Experimental Server Capability:</strong> <code>{ "matchingBrace": boolean }</code></p>
<p>This request is sent from client to server to handle "Matching Brace" editor action.</p>
<p><strong>Method:</strong> <code>experimental/matchingBrace</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>MatchingBraceParams</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>,</a-p>
    <a-c>/// Position for each cursor</a-c>
    <a-pr>positions</a-pr>: <a-t>Position</a-t><a-p>[],</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong></p>
<pre class="language-typescript"><a-t>Position</a-t><a-p>[</a-p><a-v>]</a-v></pre>
<h3>Example</h3>
<pre class="language-rust"><a-k>fn</a-k> <a-f>main</a-f><a-p>()</a-p> <a-p>{</a-p>
    <a-k>let</a-k> x<a-p>:</a-p> <a-t>Vec</a-t><a-p>&lt;()&gt;</a-p><a-c>/*cursor here*/</a-c> = <a-m>vec!</a-m><a-p>[]</a-p>
<a-p>}</a-p></pre>
<p><code>experimental/matchingBrace</code> yields the position of <code>&lt;</code>.
In many cases, matching braces can be handled by the editor.
However, some cases (like disambiguating between generics and comparison operations) need a real parser.
Moreover, it would be cool if editors didn't need to implement even basic language parsing</p>
<h3>Unresolved Question</h3>
<ul>
<li>Should we return a nested brace structure, to allow paredit-like actions of jump <em>out</em> of the current brace pair?
This is how <code>SelectionRange</code> request works.</li>
<li>Alternatively, should we perhaps flag certain <code>SelectionRange</code>s as being brace pairs?</li>
</ul>
<h2>Runnables</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/944</p>
<p><strong>Experimental Server Capability:</strong> <code>{ "runnables": { "kinds": string[] } }</code></p>
<p>This request is sent from client to server to get the list of things that can be run (tests, binaries, <code>cargo check -p</code>).</p>
<p><strong>Method:</strong> <code>experimental/runnables</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>RunnablesParams</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>;</a-p>
    <a-c>/// If null, compute runnables for the whole file.</a-c>
    <a-pr>position</a-pr>?: <a-t>Position</a-t><a-p>;</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong> <code>Runnable[]</code></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>Runnable</a-t> <a-p>{</a-p>
    <a-pr>label</a-pr>: <a-t>string</a-t><a-p>;</a-p>
    <a-c>/// If this Runnable is associated with a specific function/module, etc, the location of this item</a-c>
    <a-pr>location</a-pr>?: <a-t>LocationLink</a-t><a-p>;</a-p>
    <a-c>/// Running things is necessary technology specific, `kind` needs to be advertised via server capabilities,</a-c>
    <a-c>// the type of `args` is specific to `kind`. The actual running is handled by the client.</a-c>
    <a-pr>kind</a-pr>: <a-t>string</a-t><a-p>;</a-p>
    <a-pr>args</a-pr>: <a-t>any</a-t><a-p>;</a-p>
<a-p>}</a-p></pre>
<p>rust-analyzer supports only one <code>kind</code>, <code>"cargo"</code>. The <code>args</code> for <code>"cargo"</code> look like this:</p>
<pre class="language-typescript"><a-p>{</a-p>
    <a-pr>workspaceRoot</a-pr>?: <a-v>string</a-v><a-p>;</a-p>
    cargoArgs: <a-v>string</a-v><a-p>[</a-p><a-v>];</a-v><a-v>
    cargoExtraArgs: </a-v><a-v>string</a-v><a-p>[</a-p><a-v>];</a-v><a-v>
    executableArgs: </a-v><a-v>string</a-v><a-p>[</a-p><a-v>];</a-v><a-v>
    expectTest?: </a-v><a-v>boolean</a-v><a-p>;</a-p><a-v>
    overrideCargo?: </a-v><a-v>string</a-v><a-p>;</a-p><a-v>
</a-v><a-p>}</a-p></pre>
<h2>Open External Documentation</h2>
<p>This request is sent from client to server to get a URL to documentation for the symbol under the cursor, if available.</p>
<p><strong>Method</strong> <code>experimental/externalDocs</code></p>
<p><strong>Request:</strong>: <code>TextDocumentPositionParams</code></p>
<p><strong>Response</strong> <code>string | null</code></p>
<h2>Analyzer Status</h2>
<p><strong>Method:</strong> <code>rust-analyzer/analyzerStatus</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>AnalyzerStatusParams</a-t> <a-p>{</a-p>
    <a-c>/// If specified, show dependencies of the current file.</a-c>
    <a-pr>textDocument</a-pr>?: <a-t>TextDocumentIdentifier</a-t><a-p>;</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong> <code>string</code></p>
<p>Returns internal status message, mostly for debugging purposes.</p>
<h2>Reload Workspace</h2>
<p><strong>Method:</strong> <code>rust-analyzer/reloadWorkspace</code></p>
<p><strong>Request:</strong> <code>null</code></p>
<p><strong>Response:</strong> <code>null</code></p>
<p>Reloads project information (that is, re-executes <code>cargo metadata</code>).</p>
<h2>Server Status</h2>
<p><strong>Experimental Client Capability:</strong> <code>{ "serverStatusNotification": boolean }</code></p>
<p><strong>Method:</strong> <code>experimental/serverStatus</code></p>
<p><strong>Notification:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>ServerStatusParams</a-t> <a-p>{</a-p>
    <a-c>/// `ok` means that the server is completely functional.</a-c>
    <a-c>///</a-c>
    <a-c>/// `warning` means that the server is partially functional.</a-c>
    <a-c>/// It can answer correctly to most requests, but some results</a-c>
    <a-c>/// might be wrong due to, for example, some missing dependencies.</a-c>
    <a-c>///</a-c>
    <a-c>/// `error` means that the server is not functional. For example,</a-c>
    <a-c>/// there&#39;s a fatal build configuration problem. The server might</a-c>
    <a-c>/// still give correct answers to simple requests, but most results</a-c>
    <a-c>/// will be incomplete or wrong.</a-c>
    <a-pr>health</a-pr>: <a-s>&quot;ok&quot;</a-s> <a-o>|</a-o> <a-s>&quot;warning&quot;</a-s> <a-o>|</a-o> <a-s>&quot;error&quot;</a-s><a-p>,</a-p>
    <a-c>/// Is there any pending background work which might change the status?</a-c>
    <a-c>/// For example, are dependencies being downloaded?</a-c>
    <a-pr>quiescent</a-pr>: <a-t>boolean</a-t><a-p>,</a-p>
    <a-c>/// Explanatory message to show on hover.</a-c>
    <a-pr>message</a-pr>?: <a-t>string</a-t><a-p>,</a-p>
<a-p>}</a-p></pre>
<p>This notification is sent from server to client.
The client can use it to display <em>persistent</em> status to the user (in modline).
It is similar to the <code>showMessage</code>, but is intended for stares rather than point-in-time events.</p>
<p>Note that this functionality is intended primarily to inform the end user about the state of the server.
In particular, it's valid for the client to completely ignore this extension.
Clients are discouraged from but are allowed to use the <code>health</code> status to decide if it's worth sending a request to the server.</p>
<h2>Syntax Tree</h2>
<p><strong>Method:</strong> <code>rust-analyzer/syntaxTree</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>SyntaxTreeParams</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>,</a-p>
    <a-pr>range</a-pr>?: <a-t>Range</a-t><a-p>,</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong> <code>string</code></p>
<p>Returns textual representation of a parse tree for the file/selected region.
Primarily for debugging, but very useful for all people working on rust-analyzer itself.</p>
<h2>View Hir</h2>
<p><strong>Method:</strong> <code>rust-analyzer/viewHir</code></p>
<p><strong>Request:</strong> <code>TextDocumentPositionParams</code></p>
<p><strong>Response:</strong> <code>string</code></p>
<p>Returns a textual representation of the HIR of the function containing the cursor.
For debugging or when working on rust-analyzer itself.</p>
<h2>View File Text</h2>
<p><strong>Method:</strong> <code>rust-analyzer/viewFileText</code></p>
<p><strong>Request:</strong> <code>TextDocumentIdentifier</code></p>
<p><strong>Response:</strong> <code>string</code></p>
<p>Returns the text of a file as seen by the server.
This is for debugging file sync problems.</p>
<h2>View ItemTree</h2>
<p><strong>Method:</strong> <code>rust-analyzer/viewItemTree</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>ViewItemTreeParams</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>,</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong> <code>string</code></p>
<p>Returns a textual representation of the <code>ItemTree</code> of the currently open file, for debugging.</p>
<h2>View Crate Graph</h2>
<p><strong>Method:</strong> <code>rust-analyzer/viewCrateGraph</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>ViewCrateGraphParams</a-t> <a-p>{</a-p>
    <a-pr>full</a-pr>: <a-t>boolean</a-t><a-p>,</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong> <code>string</code></p>
<p>Renders rust-analyzer's crate graph as an SVG image.</p>
<p>If <code>full</code> is <code>true</code>, the graph includes non-workspace crates (crates.io dependencies as well as sysroot crates).</p>
<h2>Shuffle Crate Graph</h2>
<p><strong>Method:</strong> <code>rust-analyzer/shuffleCrateGraph</code></p>
<p><strong>Request:</strong> <code>null</code></p>
<p>Shuffles the crate IDs in the crate graph, for debugging purposes.</p>
<h2>Expand Macro</h2>
<p><strong>Method:</strong> <code>rust-analyzer/expandMacro</code></p>
<p><strong>Request:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>ExpandMacroParams</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>,</a-p>
    <a-pr>position</a-pr>: <a-t>Position</a-t><a-p>,</a-p>
<a-p>}</a-p></pre>
<p><strong>Response:</strong></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>ExpandedMacro</a-t> <a-p>{</a-p>
    <a-pr>name</a-pr>: <a-t>string</a-t><a-p>,</a-p>
    <a-pr>expansion</a-pr>: <a-t>string</a-t><a-p>,</a-p>
<a-p>}</a-p></pre>
<p>Expands macro call at a given position.</p>
<h2>Hover Actions</h2>
<p><strong>Experimental Client Capability:</strong> <code>{ "hoverActions": boolean }</code></p>
<p>If this capability is set, <code>Hover</code> request returned from the server might contain an additional field, <code>actions</code>:</p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>Hover</a-t> <a-p>{</a-p>
    ...
    <a-pr>actions</a-pr>?: <a-t>CommandLinkGroup</a-t><a-p>[];</a-p>
<a-p>}</a-p>

<a-k>interface</a-k> <a-t>CommandLink</a-t> <a-k>extends</a-k> <a-t>Command</a-t> <a-p>{</a-p>
    <a-c>/**
     * A tooltip for the command, when represented in the UI.
     */</a-c>
    <a-pr>tooltip</a-pr>?: <a-t>string</a-t><a-p>;</a-p>
<a-p>}</a-p>

<a-k>interface</a-k> <a-t>CommandLinkGroup</a-t> <a-p>{</a-p>
    <a-pr>title</a-pr>?: <a-t>string</a-t><a-p>;</a-p>
    <a-pr>commands</a-pr>: <a-t>CommandLink</a-t><a-p>[];</a-p>
<a-p>}</a-p></pre>
<p>Such actions on the client side are appended to a hover bottom as command links:</p>
<pre>  +-----------------------------+
  | Hover content               |
  |                             |
  +-----------------------------+
  | _Action1_ | _Action2_       |  &lt;- first group, no TITLE
  +-----------------------------+
  | TITLE _Action1_ | _Action2_ |  &lt;- second group
  +-----------------------------+
  ...
</pre>
<h2>Open Cargo.toml</h2>
<p><strong>Upstream Issue:</strong> https://github.com/rust-analyzer/rust-analyzer/issues/6462</p>
<p><strong>Experimental Server Capability:</strong> <code>{ "openCargoToml": boolean }</code></p>
<p>This request is sent from client to server to open the current project's Cargo.toml</p>
<p><strong>Method:</strong> <code>experimental/openCargoToml</code></p>
<p><strong>Request:</strong> <code>OpenCargoTomlParams</code></p>
<p><strong>Response:</strong> <code>Location | null</code></p>
<h3>Example</h3>
<pre class="language-rust"><a-c>// Cargo.toml</a-c>
<a-p>[</a-p>package<a-p>]</a-p>
<a-c>// src/main.rs</a-c>

<a-c>/* cursor here*/</a-c></pre>
<p><code>experimental/openCargoToml</code> returns a single <code>Link</code> to the start of the <code>[package]</code> keyword.</p>
<h2>Related tests</h2>
<p>This request is sent from client to server to get the list of tests for the specified position.</p>
<p><strong>Method:</strong> <code>rust-analyzer/relatedTests</code></p>
<p><strong>Request:</strong> <code>TextDocumentPositionParams</code></p>
<p><strong>Response:</strong> <code>TestInfo[]</code></p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>TestInfo</a-t> <a-p>{</a-p>
    <a-pr>runnable</a-pr>: <a-t>Runnable</a-t><a-p>;</a-p>
<a-p>}</a-p></pre>
<h2>Hover Range</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/377</p>
<p><strong>Experimental Server Capability:</strong> { "hoverRange": boolean }</p>
<p>This extension allows passing a <code>Range</code> as a <code>position</code> field of <code>HoverParams</code>.
The primary use-case is to use the hover request to show the type of the expression currently selected.</p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>HoverParams</a-t> <a-k>extends</a-k> <a-t>WorkDoneProgressParams</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>;</a-p>
    <a-pr>position</a-pr>: <a-t>Range</a-t> <a-o>|</a-o> <a-t>Position</a-t><a-p>;</a-p>
<a-p>}</a-p></pre>
<p>Whenever the client sends a <code>Range</code>, it is understood as the current selection and any hover included in the range will show the type of the expression if possible.</p>
<h3>Example</h3>
<pre class="language-rust"><a-k>fn</a-k> <a-f>main</a-f><a-p>()</a-p> <a-p>{</a-p>
    <a-k>let</a-k> expression = $<a-co>01</a-co> + <a-co>2</a-co> <a-o>*</a-o> <a-co>3</a-co>$<a-co>0</a-co><a-p>;</a-p>
<a-p>}</a-p></pre>
<p>Triggering a hover inside the selection above will show a result of <code>i32</code>.</p>
<h2>Move Item</h2>
<p><strong>Upstream Issue:</strong> https://github.com/rust-analyzer/rust-analyzer/issues/6823</p>
<p>This request is sent from client to server to move item under cursor or selection in some direction.</p>
<p><strong>Method:</strong> <code>experimental/moveItem</code></p>
<p><strong>Request:</strong> <code>MoveItemParams</code></p>
<p><strong>Response:</strong> <code>SnippetTextEdit[]</code></p>
<pre class="language-typescript"><a-k>export</a-k> <a-k>interface</a-k> <a-t>MoveItemParams</a-t> <a-p>{</a-p>
    <a-pr>textDocument</a-pr>: <a-t>TextDocumentIdentifier</a-t><a-p>,</a-p>
    <a-pr>range</a-pr>: <a-t>Range</a-t><a-p>,</a-p>
    <a-pr>direction</a-pr>: <a-t>Direction</a-t>
<a-p>}</a-p>

<a-k>export</a-k> <a-k>const</a-k> <a-k>enum</a-k> <a-t>Direction</a-t> <a-p>{</a-p>
    <a-pr>Up</a-pr> <a-o>=</a-o> <a-s>&quot;Up&quot;</a-s><a-p>,</a-p>
    <a-pr>Down</a-pr> <a-o>=</a-o> <a-s>&quot;Down&quot;</a-s>
<a-p>}</a-p></pre>
<h2>Workspace Symbols Filtering</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/941</p>
<p><strong>Experimental Server Capability:</strong> <code>{ "workspaceSymbolScopeKindFiltering": boolean }</code></p>
<p>Extends the existing <code>workspace/symbol</code> request with ability to filter symbols by broad scope and kind of symbol.
If this capability is set, <code>workspace/symbol</code> parameter gains two new optional fields:</p>
<pre class="language-typescript"><a-k>interface</a-k> <a-t>WorkspaceSymbolParams</a-t> <a-p>{</a-p>
    <a-c>/**
     * Return only the symbols defined in the specified scope.
     */</a-c>
    <a-pr>searchScope</a-pr>?: <a-t>WorkspaceSymbolSearchScope</a-t><a-p>;</a-p>
    <a-c>/**
     * Return only the symbols of specified kinds.
     */</a-c>
    <a-pr>searchKind</a-pr>?: <a-t>WorkspaceSymbolSearchKind</a-t><a-p>;</a-p>
    ...
<a-p>}</a-p>

<a-k>const</a-k> <a-k>enum</a-k> <a-t>WorkspaceSymbolSearchScope</a-t> <a-p>{</a-p>
    <a-pr>Workspace</a-pr> <a-o>=</a-o> <a-s>&quot;workspace&quot;</a-s><a-p>,</a-p>
    <a-pr>WorkspaceAndDependencies</a-pr> <a-o>=</a-o> <a-s>&quot;workspaceAndDependencies&quot;</a-s>
<a-p>}</a-p>

<a-k>const</a-k> <a-k>enum</a-k> <a-t>WorkspaceSymbolSearchKind</a-t> <a-p>{</a-p>
    <a-pr>OnlyTypes</a-pr> <a-o>=</a-o> <a-s>&quot;onlyTypes&quot;</a-s><a-p>,</a-p>
    <a-pr>AllSymbols</a-pr> <a-o>=</a-o> <a-s>&quot;allSymbols&quot;</a-s>
<a-p>}</a-p></pre>
<h2>Client Commands</h2>
<p><strong>Upstream Issue:</strong> https://github.com/microsoft/language-server-protocol/issues/642</p>
<p><strong>Experimental Client Capability:</strong> <code>{ "commands?": ClientCommandOptions }</code></p>
<p>Certain LSP types originating on the server, notably code lenses, embed commands.
Commands can be serviced either by the server or by the client.
However, the server doesn't know which commands are available on the client.</p>
<p>This extensions allows the client to communicate this info.</p>
<pre class="language-typescript"><a-k>export</a-k> <a-k>interface</a-k> <a-t>ClientCommandOptions</a-t> <a-p>{</a-p>
    <a-c>/**
     * The commands to be executed on the client
     */</a-c>
    <a-pr>commands</a-pr>: <a-t>string</a-t><a-p>[];</a-p>
<a-p>}</a-p></pre>
</section><div class="code-panel"><pre class="code src language-markdown"><span class="code-line"><a class="ln" id="L1" href="#L1">1</a><span class="code-text"><a-c>&lt;!---</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L2" href="#L2">2</a><span class="code-text"><a-p>lsp_ext.rs hash: 2a188defec26cc7c</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L3" href="#L3">3</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L4" href="#L4">4</a><span class="code-text"><a-p>If you need to change the above hash to make the test pass, please check if you</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L5" href="#L5">5</a><span class="code-text"><a-p>need to adjust this doc as well and ping this issue:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L6" href="#L6">6</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L7" href="#L7">7</a><span class="code-text"><a-p>  https://github.com/rust-analyzer/rust-analyzer/issues/4604</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L8" href="#L8">8</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L9" href="#L9">9</a><span class="code-text"><a-p>---&gt;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L10" href="#L10">10</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L11" href="#L11">11</a><span class="code-text"><a-p># </a-p><a-tt>LSP Extensions</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L12" href="#L12">12</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L13" href="#L13">13</a><span class="code-text"><a-p>This document describes LSP extensions used by rust-analyzer.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L14" href="#L14">14</a><span class="code-text"><a-p>It&#39;s a best effort document, when in doubt, consult the source (and send a PR with clarification ;-) ).</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L15" href="#L15">15</a><span class="code-text"><a-p>We aim to upstream all non Rust-specific extensions to the protocol, but this is not a top priority.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L16" href="#L16">16</a><span class="code-text"><a-p>All capabilities are enabled via the `experimental` field of `ClientCapabilities` or `ServerCapabilities`.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L17" href="#L17">17</a><span class="code-text"><a-p>Requests which we hope to upstream live under `experimental/` namespace.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L18" href="#L18">18</a><span class="code-text"><a-p>Requests, which are likely to always remain specific to `rust-analyzer` are under `rust-analyzer/` namespace.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L19" href="#L19">19</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L20" href="#L20">20</a><span class="code-text"><a-p>If you want to be notified about the changes to this document, subscribe to [#4604](https://github.com/rust-analyzer/rust-analyzer/issues/4604).</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L21" href="#L21">21</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L22" href="#L22">22</a><span class="code-text"><a-p>## </a-p><a-tt>UTF-8 offsets</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L23" href="#L23">23</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L24" href="#L24">24</a><span class="code-text"><a-p>rust-analyzer supports clangd&#39;s extension for opting into UTF-8 as the coordinate space for offsets (by default, LSP uses UTF-16 offsets).</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L25" href="#L25">25</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L26" href="#L26">26</a><span class="code-text"><a-p>https://clangd.llvm.org/extensions.html#utf-8-offsets</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L27" href="#L27">27</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L28" href="#L28">28</a><span class="code-text"><a-p>## </a-p><a-tt>Configuration in `initializationOptions`</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L29" href="#L29">29</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L30" href="#L30">30</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/567</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L31" href="#L31">31</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L32" href="#L32">32</a><span class="code-text"><a-p>The `initializationOptions` field of the `InitializeParams` of the initialization request should contain the `&quot;rust-analyzer&quot;` section of the configuration.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L33" href="#L33">33</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L34" href="#L34">34</a><span class="code-text"><a-p>`rust-analyzer` normally sends a `&quot;workspace/configuration&quot;` request with `{ &quot;items&quot;: [&quot;rust-analyzer&quot;] }` payload.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L35" href="#L35">35</a><span class="code-text"><a-p>However, the server can&#39;t do this during initialization.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L36" href="#L36">36</a><span class="code-text"><a-p>At the same time some essential configuration parameters are needed early on, before servicing requests.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L37" href="#L37">37</a><span class="code-text"><a-p>For this reason, we ask that `initializationOptions` contains the configuration, as if the server did make a `&quot;workspace/configuration&quot;` request.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L38" href="#L38">38</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L39" href="#L39">39</a><span class="code-text"><a-p>If a language client does not know about `rust-analyzer`&#39;s configuration options it can get sensible defaults by doing any of the following:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L40" href="#L40">40</a><span class="code-text"><a-p> * Not sending `initializationOptions`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L41" href="#L41">41</a><span class="code-text"><a-p> * Sending `&quot;initializationOptions&quot;: null`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L42" href="#L42">42</a><span class="code-text"><a-p> * Sending `&quot;initializationOptions&quot;: {}`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L43" href="#L43">43</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L44" href="#L44">44</a><span class="code-text"><a-p>## </a-p><a-tt>Snippet `TextEdit`</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L45" href="#L45">45</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L46" href="#L46">46</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/724</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L47" href="#L47">47</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L48" href="#L48">48</a><span class="code-text"><a-p>**Experimental Client Capability:** `{ &quot;snippetTextEdit&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L49" href="#L49">49</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L50" href="#L50">50</a><span class="code-text"><a-p>If this capability is set, `WorkspaceEdit`s returned from `codeAction` requests and `TextEdit`s returned from `textDocument/onTypeFormatting` requests might contain `SnippetTextEdit`s instead of usual `TextEdit`s:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L51" href="#L51">51</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L52" href="#L52">52</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L53" href="#L53">53</a><span class="code-text"><a-p>interface </a-p><a-t>SnippetTextEdit</a-t><a-p> </a-p><a-k>extends</a-k><a-p> </a-p><a-t>TextEdit</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L54" href="#L54">54</a><span class="code-text"><a-p>    </a-p><a-pr>insertTextFormat</a-pr><a-p>?: </a-p><a-t>InsertTextFormat</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L55" href="#L55">55</a><span class="code-text"><a-p>    </a-p><a-pr>annotationId</a-pr><a-p>?: </a-p><a-t>ChangeAnnotationIdentifier</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L56" href="#L56">56</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L57" href="#L57">57</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L58" href="#L58">58</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L59" href="#L59">59</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L60" href="#L60">60</a><span class="code-text"><a-p>export </a-p><a-k>interface</a-k><a-p> </a-p><a-t>TextDocumentEdit</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L61" href="#L61">61</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>OptionalVersionedTextDocumentIdentifier</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L62" href="#L62">62</a><span class="code-text"><a-p>    </a-p><a-pr>edits</a-pr><a-p>: (</a-p><a-t>TextEdit</a-t><a-p> </a-p><a-o>|</a-o><a-p> </a-p><a-t>SnippetTextEdit</a-t><a-p>)[];</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L63" href="#L63">63</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L64" href="#L64">64</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L65" href="#L65">65</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L66" href="#L66">66</a><span class="code-text"><a-p>When applying such code action or text edit, the editor should insert snippet, with tab stops and placeholder.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L67" href="#L67">67</a><span class="code-text"><a-p>At the moment, rust-analyzer guarantees that only a single edit will have `InsertTextFormat.Snippet`.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L68" href="#L68">68</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L69" href="#L69">69</a><span class="code-text"><a-p>### </a-p><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L70" href="#L70">70</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L71" href="#L71">71</a><span class="code-text"><a-p>&quot;Add `derive`&quot; code action transforms `struct S;` into `#[derive($0)] struct S;`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L72" href="#L72">72</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L73" href="#L73">73</a><span class="code-text"><a-p>### </a-p><a-tt>Unresolved Questions</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L74" href="#L74">74</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L75" href="#L75">75</a><span class="code-text"><a-p>* Where exactly are `SnippetTextEdit`s allowed (only in code actions at the moment)?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L76" href="#L76">76</a><span class="code-text"><a-p>* Can snippets span multiple files (so far, no)?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L77" href="#L77">77</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L78" href="#L78">78</a><span class="code-text"><a-p>## </a-p><a-tt>`CodeAction` Groups</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L79" href="#L79">79</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L80" href="#L80">80</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/994</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L81" href="#L81">81</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L82" href="#L82">82</a><span class="code-text"><a-p>**Experimental Client Capability:** `{ &quot;codeActionGroup&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L83" href="#L83">83</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L84" href="#L84">84</a><span class="code-text"><a-p>If this capability is set, `CodeAction`s returned from the server contain an additional field, `group`:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L85" href="#L85">85</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L86" href="#L86">86</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L87" href="#L87">87</a><span class="code-text"><a-p>interface </a-p><a-t>CodeAction</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L88" href="#L88">88</a><span class="code-text"><a-p>    </a-p><a-pr>title</a-pr><a-p>: </a-p><a-t>string</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L89" href="#L89">89</a><span class="code-text"><a-p>    </a-p><a-pr>group</a-pr><a-p>?: </a-p><a-t>string</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L90" href="#L90">90</a><span class="code-text"><a-p>    ...</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L91" href="#L91">91</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L92" href="#L92">92</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L93" href="#L93">93</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L94" href="#L94">94</a><span class="code-text"><a-p>All code-actions with the same `group` should be grouped under single (extendable) entry in lightbulb menu.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L95" href="#L95">95</a><span class="code-text"><a-p>The set of actions `[ { title: &quot;foo&quot; }, { group: &quot;frobnicate&quot;, title: &quot;bar&quot; }, { group: &quot;frobnicate&quot;, title: &quot;baz&quot; }]` should be rendered as</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L96" href="#L96">96</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L97" href="#L97">97</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L98" href="#L98">98</a><span class="code-text"><a-p>💡</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L99" href="#L99">99</a><span class="code-text"><a-p>  +-------------+</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L100" href="#L100">100</a><span class="code-text"><a-p>  | foo         |</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L101" href="#L101">101</a><span class="code-text"><a-p>  +-------------+-----+</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L102" href="#L102">102</a><span class="code-text"><a-p>  | frobnicate &gt;| bar |</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L103" href="#L103">103</a><span class="code-text"><a-p>  +-------------+-----+</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L104" href="#L104">104</a><span class="code-text"><a-p>                | baz |</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L105" href="#L105">105</a><span class="code-text"><a-p>                +-----+</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L106" href="#L106">106</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L107" href="#L107">107</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L108" href="#L108">108</a><span class="code-text"><a-p>Alternatively, selecting `frobnicate` could present a user with an additional menu to choose between `bar` and `baz`.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L109" href="#L109">109</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L110" href="#L110">110</a><span class="code-text"><a-p>### </a-p><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L111" href="#L111">111</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L112" href="#L112">112</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L113" href="#L113">113</a><span class="code-text"><a-p>fn </a-p><a-f>main</a-f><a-p>() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L114" href="#L114">114</a><span class="code-text"><a-p>    </a-p><a-k>let</a-k><a-p> x: </a-p><a-t>Entry</a-t><a-c>/*cursor here*/</a-c><a-p> = </a-p><a-m>todo!</a-m><a-p>();</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L115" href="#L115">115</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L116" href="#L116">116</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L117" href="#L117">117</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L118" href="#L118">118</a><span class="code-text"><a-p>Invoking code action at this position will yield two code actions for importing `Entry` from either `collections::HashMap` or `collection::BTreeMap`, grouped under a single &quot;import&quot; group.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L119" href="#L119">119</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L120" href="#L120">120</a><span class="code-text"><a-p>### </a-p><a-tt>Unresolved Questions</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L121" href="#L121">121</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L122" href="#L122">122</a><span class="code-text"><a-p>* Is a fixed two-level structure enough?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L123" href="#L123">123</a><span class="code-text"><a-p>* Should we devise a general way to encode custom interaction protocols for GUI refactorings?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L124" href="#L124">124</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L125" href="#L125">125</a><span class="code-text"><a-p>## </a-p><a-tt>Parent Module</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L126" href="#L126">126</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L127" href="#L127">127</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/1002</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L128" href="#L128">128</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L129" href="#L129">129</a><span class="code-text"><a-p>**Experimental Server Capability:** `{ &quot;parentModule&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L130" href="#L130">130</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L131" href="#L131">131</a><span class="code-text"><a-p>This request is sent from client to server to handle &quot;Goto Parent Module&quot; editor action.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L132" href="#L132">132</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L133" href="#L133">133</a><span class="code-text"><a-p>**Method:** `experimental/parentModule`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L134" href="#L134">134</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L135" href="#L135">135</a><span class="code-text"><a-p>**Request:** `TextDocumentPositionParams`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L136" href="#L136">136</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L137" href="#L137">137</a><span class="code-text"><a-p>**Response:** `Location | Location[] | LocationLink[] | null`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L138" href="#L138">138</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L139" href="#L139">139</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L140" href="#L140">140</a><span class="code-text"><a-p>### </a-p><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L141" href="#L141">141</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L142" href="#L142">142</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L143" href="#L143">143</a><span class="code-text"><a-p>// src/main.rs</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L144" href="#L144">144</a><span class="code-text"><a-p>mod foo;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L145" href="#L145">145</a><span class="code-text"><a-p>// src/foo.rs</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L146" href="#L146">146</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L147" href="#L147">147</a><span class="code-text"><a-p>/* cursor here*/</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L148" href="#L148">148</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L149" href="#L149">149</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L150" href="#L150">150</a><span class="code-text"><a-p>`experimental/parentModule` returns a single `Link` to the `mod foo;` declaration.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L151" href="#L151">151</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L152" href="#L152">152</a><span class="code-text"><a-p>### </a-p><a-tt>Unresolved Question</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L153" href="#L153">153</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L154" href="#L154">154</a><span class="code-text"><a-p>* An alternative would be to use a more general &quot;gotoSuper&quot; request, which would work for super methods, super classes and super modules.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L155" href="#L155">155</a><span class="code-text"><a-p>  This is the approach IntelliJ Rust is taking.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L156" href="#L156">156</a><span class="code-text"><a-p>  However, experience shows that super module (which generally has a feeling of navigation between files) should be separate.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L157" href="#L157">157</a><span class="code-text"><a-p>  If you want super module, but the cursor happens to be inside an overridden function, the behavior with single &quot;gotoSuper&quot; request is surprising.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L158" href="#L158">158</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L159" href="#L159">159</a><span class="code-text"><a-p>## </a-p><a-tt>Join Lines</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L160" href="#L160">160</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L161" href="#L161">161</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/992</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L162" href="#L162">162</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L163" href="#L163">163</a><span class="code-text"><a-p>**Experimental Server Capability:** `{ &quot;joinLines&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L164" href="#L164">164</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L165" href="#L165">165</a><span class="code-text"><a-p>This request is sent from client to server to handle &quot;Join Lines&quot; editor action.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L166" href="#L166">166</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L167" href="#L167">167</a><span class="code-text"><a-p>**Method:** `experimental/joinLines`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L168" href="#L168">168</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L169" href="#L169">169</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L170" href="#L170">170</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L171" href="#L171">171</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L172" href="#L172">172</a><span class="code-text"><a-p>interface </a-p><a-t>JoinLinesParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L173" href="#L173">173</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L174" href="#L174">174</a><span class="code-text"><a-p>    </a-p><a-c>/// Currently active selections/cursor offsets.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L175" href="#L175">175</a><span class="code-text"><a-p>    </a-p><a-c>/// This is an array to support multiple cursors.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L176" href="#L176">176</a><span class="code-text"><a-p>    </a-p><a-pr>ranges</a-pr><a-p>: </a-p><a-t>Range</a-t><a-p>[],</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L177" href="#L177">177</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L178" href="#L178">178</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L179" href="#L179">179</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L180" href="#L180">180</a><span class="code-text"><a-p>**Response:** `TextEdit[]`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L181" href="#L181">181</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L182" href="#L182">182</a><span class="code-text"><a-p>### </a-p><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L183" href="#L183">183</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L184" href="#L184">184</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L185" href="#L185">185</a><span class="code-text"><a-p>fn </a-p><a-f>main</a-f><a-p>() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L186" href="#L186">186</a><span class="code-text"><a-p>    </a-p><a-c>/*cursor here*/</a-c><a-k>let</a-k><a-p> x = {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L187" href="#L187">187</a><span class="code-text"><a-p>        </a-p><a-co>92</a-co></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L188" href="#L188">188</a><span class="code-text"><a-p>    };</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L189" href="#L189">189</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L190" href="#L190">190</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L191" href="#L191">191</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L192" href="#L192">192</a><span class="code-text"><a-p>`experimental/joinLines` yields (curly braces are automagically removed)</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L193" href="#L193">193</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L194" href="#L194">194</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L195" href="#L195">195</a><span class="code-text"><a-p>fn </a-p><a-f>main</a-f><a-p>() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L196" href="#L196">196</a><span class="code-text"><a-p>    </a-p><a-k>let</a-k><a-p> x = </a-p><a-co>92</a-co><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L197" href="#L197">197</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L198" href="#L198">198</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L199" href="#L199">199</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L200" href="#L200">200</a><span class="code-text"><a-p>### </a-p><a-tt>Unresolved Question</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L201" href="#L201">201</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L202" href="#L202">202</a><span class="code-text"><a-p>* What is the position of the cursor after `joinLines`?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L203" href="#L203">203</a><span class="code-text"><a-p>  Currently, this is left to editor&#39;s discretion, but it might be useful to specify on the server via snippets.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L204" href="#L204">204</a><span class="code-text"><a-p>  However, it then becomes unclear how it works with multi cursor.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L205" href="#L205">205</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L206" href="#L206">206</a><span class="code-text"><a-p>## </a-p><a-tt>On Enter</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L207" href="#L207">207</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L208" href="#L208">208</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/1001</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L209" href="#L209">209</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L210" href="#L210">210</a><span class="code-text"><a-p>**Experimental Server Capability:** `{ &quot;onEnter&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L211" href="#L211">211</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L212" href="#L212">212</a><span class="code-text"><a-p>This request is sent from client to server to handle the &lt;kbd&gt;Enter&lt;/kbd&gt; key press.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L213" href="#L213">213</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L214" href="#L214">214</a><span class="code-text"><a-p>**Method:** `experimental/onEnter`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L215" href="#L215">215</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L216" href="#L216">216</a><span class="code-text"><a-p>**Request:**: `TextDocumentPositionParams`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L217" href="#L217">217</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L218" href="#L218">218</a><span class="code-text"><a-p>**Response:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L219" href="#L219">219</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L220" href="#L220">220</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L221" href="#L221">221</a><span class="code-text"><a-p>SnippetTextEdit[</a-p><a-v>]</a-v></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L222" href="#L222">222</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L223" href="#L223">223</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L224" href="#L224">224</a><span class="code-text"><a-p>###</a-p><a-v> </a-v><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L225" href="#L225">225</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L226" href="#L226">226</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L227" href="#L227">227</a><span class="code-text"><a-p>fn </a-p><a-f>main</a-f><a-p>() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L228" href="#L228">228</a><span class="code-text"><a-p>    </a-p><a-c>// Some /*cursor here*/ docs</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L229" href="#L229">229</a><span class="code-text"><a-p>    </a-p><a-k>let</a-k><a-p> x = </a-p><a-co>92</a-co><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L230" href="#L230">230</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L231" href="#L231">231</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L232" href="#L232">232</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L233" href="#L233">233</a><span class="code-text"><a-p>`experimental/onEnter` returns the following snippet</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L234" href="#L234">234</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L235" href="#L235">235</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L236" href="#L236">236</a><span class="code-text"><a-p>fn </a-p><a-f>main</a-f><a-p>() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L237" href="#L237">237</a><span class="code-text"><a-p>    </a-p><a-c>// Some</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L238" href="#L238">238</a><span class="code-text"><a-p>    </a-p><a-c>// $0 docs</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L239" href="#L239">239</a><span class="code-text"><a-p>    </a-p><a-k>let</a-k><a-p> x = </a-p><a-co>92</a-co><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L240" href="#L240">240</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L241" href="#L241">241</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L242" href="#L242">242</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L243" href="#L243">243</a><span class="code-text"><a-p>The primary goal of `onEnter` is to handle automatic indentation when opening a new line.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L244" href="#L244">244</a><span class="code-text"><a-p>This is not yet implemented.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L245" href="#L245">245</a><span class="code-text"><a-p>The secondary goal is to handle fixing up syntax, like continuing doc strings and comments, and escaping `\n` in string literals.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L246" href="#L246">246</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L247" href="#L247">247</a><span class="code-text"><a-p>As proper cursor positioning is raison-d&#39;etat for `onEnter`, it uses `SnippetTextEdit`.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L248" href="#L248">248</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L249" href="#L249">249</a><span class="code-text"><a-p>### </a-p><a-tt>Unresolved Question</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L250" href="#L250">250</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L251" href="#L251">251</a><span class="code-text"><a-p>* How to deal with synchronicity of the request?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L252" href="#L252">252</a><span class="code-text"><a-p>  One option is to require the client to block until the server returns the response.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L253" href="#L253">253</a><span class="code-text"><a-p>  Another option is to do a OT-style merging of edits from client and server.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L254" href="#L254">254</a><span class="code-text"><a-p>  A third option is to do a record-replay: client applies heuristic on enter immediately, then applies all user&#39;s keypresses.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L255" href="#L255">255</a><span class="code-text"><a-p>  When the server is ready with the response, the client rollbacks all the changes and applies the recorded actions on top of the correct response.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L256" href="#L256">256</a><span class="code-text"><a-p>* How to deal with multiple carets?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L257" href="#L257">257</a><span class="code-text"><a-p>* Should we extend this to arbitrary typed events and not just `onEnter`?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L258" href="#L258">258</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L259" href="#L259">259</a><span class="code-text"><a-p>## </a-p><a-tt>Structural Search Replace (SSR)</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L260" href="#L260">260</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L261" href="#L261">261</a><span class="code-text"><a-p>**Experimental Server Capability:** `{ &quot;ssr&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L262" href="#L262">262</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L263" href="#L263">263</a><span class="code-text"><a-p>This request is sent from client to server to handle structural search replace -- automated syntax tree based transformation of the source.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L264" href="#L264">264</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L265" href="#L265">265</a><span class="code-text"><a-p>**Method:** `experimental/ssr`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L266" href="#L266">266</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L267" href="#L267">267</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L268" href="#L268">268</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L269" href="#L269">269</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L270" href="#L270">270</a><span class="code-text"><a-p>interface </a-p><a-t>SsrParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L271" href="#L271">271</a><span class="code-text"><a-p>    </a-p><a-c>/// Search query.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L272" href="#L272">272</a><span class="code-text"><a-p>    </a-p><a-c>/// The specific syntax is specified outside of the protocol.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L273" href="#L273">273</a><span class="code-text"><a-p>    </a-p><a-pr>query</a-pr><a-p>: </a-p><a-t>string</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L274" href="#L274">274</a><span class="code-text"><a-p>    </a-p><a-c>/// If true, only check the syntax of the query and don&#39;t compute the actual edit.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L275" href="#L275">275</a><span class="code-text"><a-p>    </a-p><a-pr>parseOnly</a-pr><a-p>: </a-p><a-t>boolean</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L276" href="#L276">276</a><span class="code-text"><a-p>    </a-p><a-c>/// The current text document. This and `position` will be used to determine in what scope</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L277" href="#L277">277</a><span class="code-text"><a-p>    </a-p><a-c>/// paths in `query` should be resolved.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L278" href="#L278">278</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L279" href="#L279">279</a><span class="code-text"><a-p>    </a-p><a-c>/// Position where SSR was invoked.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L280" href="#L280">280</a><span class="code-text"><a-p>    </a-p><a-pr>position</a-pr><a-p>: </a-p><a-t>Position</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L281" href="#L281">281</a><span class="code-text"><a-p>    </a-p><a-c>/// Current selections. Search/replace will be restricted to these if non-empty.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L282" href="#L282">282</a><span class="code-text"><a-p>    </a-p><a-pr>selections</a-pr><a-p>: </a-p><a-t>Range</a-t><a-p>[];</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L283" href="#L283">283</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L284" href="#L284">284</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L285" href="#L285">285</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L286" href="#L286">286</a><span class="code-text"><a-p>**Response:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L287" href="#L287">287</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L288" href="#L288">288</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L289" href="#L289">289</a><span class="code-text"><a-p>WorkspaceEdit</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L290" href="#L290">290</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L291" href="#L291">291</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L292" href="#L292">292</a><span class="code-text"><a-p>### </a-p><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L293" href="#L293">293</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L294" href="#L294">294</a><span class="code-text"><a-p>SSR with query `foo($a, $b) ==&gt;&gt; ($a).foo($b)` will transform, eg `foo(y + 5, z)` into `(y + 5).foo(z)`.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L295" href="#L295">295</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L296" href="#L296">296</a><span class="code-text"><a-p>### </a-p><a-tt>Unresolved Question</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L297" href="#L297">297</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L298" href="#L298">298</a><span class="code-text"><a-p>* Probably needs search without replace mode</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L299" href="#L299">299</a><span class="code-text"><a-p>* Needs a way to limit the scope to certain files.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L300" href="#L300">300</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L301" href="#L301">301</a><span class="code-text"><a-p>## </a-p><a-tt>Matching Brace</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L302" href="#L302">302</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L303" href="#L303">303</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/999</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L304" href="#L304">304</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L305" href="#L305">305</a><span class="code-text"><a-p>**Experimental Server Capability:** `{ &quot;matchingBrace&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L306" href="#L306">306</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L307" href="#L307">307</a><span class="code-text"><a-p>This request is sent from client to server to handle &quot;Matching Brace&quot; editor action.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L308" href="#L308">308</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L309" href="#L309">309</a><span class="code-text"><a-p>**Method:** `experimental/matchingBrace`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L310" href="#L310">310</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L311" href="#L311">311</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L312" href="#L312">312</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L313" href="#L313">313</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L314" href="#L314">314</a><span class="code-text"><a-p>interface </a-p><a-t>MatchingBraceParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L315" href="#L315">315</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L316" href="#L316">316</a><span class="code-text"><a-p>    </a-p><a-c>/// Position for each cursor</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L317" href="#L317">317</a><span class="code-text"><a-p>    </a-p><a-pr>positions</a-pr><a-p>: </a-p><a-t>Position</a-t><a-p>[],</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L318" href="#L318">318</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L319" href="#L319">319</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L320" href="#L320">320</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L321" href="#L321">321</a><span class="code-text"><a-p>**Response:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L322" href="#L322">322</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L323" href="#L323">323</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L324" href="#L324">324</a><span class="code-text"><a-p>Position[</a-p><a-v>]</a-v></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L325" href="#L325">325</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L326" href="#L326">326</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L327" href="#L327">327</a><span class="code-text"><a-p>###</a-p><a-v> </a-v><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L328" href="#L328">328</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L329" href="#L329">329</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L330" href="#L330">330</a><span class="code-text"><a-p>fn </a-p><a-f>main</a-f><a-p>() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L331" href="#L331">331</a><span class="code-text"><a-p>    </a-p><a-k>let</a-k><a-p> x: </a-p><a-t>Vec</a-t><a-p>&lt;()&gt;</a-p><a-c>/*cursor here*/</a-c><a-p> = </a-p><a-m>vec!</a-m><a-p>[]</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L332" href="#L332">332</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L333" href="#L333">333</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L334" href="#L334">334</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L335" href="#L335">335</a><span class="code-text"><a-p>`experimental/matchingBrace` yields the position of `&lt;`.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L336" href="#L336">336</a><span class="code-text"><a-p>In many cases, matching braces can be handled by the editor.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L337" href="#L337">337</a><span class="code-text"><a-p>However, some cases (like disambiguating between generics and comparison operations) need a real parser.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L338" href="#L338">338</a><span class="code-text"><a-p>Moreover, it would be cool if editors didn&#39;t need to implement even basic language parsing</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L339" href="#L339">339</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L340" href="#L340">340</a><span class="code-text"><a-p>### </a-p><a-tt>Unresolved Question</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L341" href="#L341">341</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L342" href="#L342">342</a><span class="code-text"><a-p>* Should we return a nested brace structure, to allow paredit-like actions of jump *out* of the current brace pair?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L343" href="#L343">343</a><span class="code-text"><a-p>  This is how `SelectionRange` request works.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L344" href="#L344">344</a><span class="code-text"><a-p>* Alternatively, should we perhaps flag certain `SelectionRange`s as being brace pairs?</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L345" href="#L345">345</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L346" href="#L346">346</a><span class="code-text"><a-p>## </a-p><a-tt>Runnables</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L347" href="#L347">347</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L348" href="#L348">348</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/944</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L349" href="#L349">349</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L350" href="#L350">350</a><span class="code-text"><a-p>**Experimental Server Capability:** `{ &quot;runnables&quot;: { &quot;kinds&quot;: string[] } }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L351" href="#L351">351</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L352" href="#L352">352</a><span class="code-text"><a-p>This request is sent from client to server to get the list of things that can be run (tests, binaries, `cargo check -p`).</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L353" href="#L353">353</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L354" href="#L354">354</a><span class="code-text"><a-p>**Method:** `experimental/runnables`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L355" href="#L355">355</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L356" href="#L356">356</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L357" href="#L357">357</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L358" href="#L358">358</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L359" href="#L359">359</a><span class="code-text"><a-p>interface </a-p><a-t>RunnablesParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L360" href="#L360">360</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L361" href="#L361">361</a><span class="code-text"><a-p>    </a-p><a-c>/// If null, compute runnables for the whole file.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L362" href="#L362">362</a><span class="code-text"><a-p>    </a-p><a-pr>position</a-pr><a-p>?: </a-p><a-t>Position</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L363" href="#L363">363</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L364" href="#L364">364</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L365" href="#L365">365</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L366" href="#L366">366</a><span class="code-text"><a-p>**Response:** `Runnable[]`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L367" href="#L367">367</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L368" href="#L368">368</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L369" href="#L369">369</a><span class="code-text"><a-p>interface </a-p><a-t>Runnable</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L370" href="#L370">370</a><span class="code-text"><a-p>    </a-p><a-pr>label</a-pr><a-p>: </a-p><a-t>string</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L371" href="#L371">371</a><span class="code-text"><a-p>    </a-p><a-c>/// If this Runnable is associated with a specific function/module, etc, the location of this item</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L372" href="#L372">372</a><span class="code-text"><a-p>    </a-p><a-pr>location</a-pr><a-p>?: </a-p><a-t>LocationLink</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L373" href="#L373">373</a><span class="code-text"><a-p>    </a-p><a-c>/// Running things is necessary technology specific, `kind` needs to be advertised via server capabilities,</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L374" href="#L374">374</a><span class="code-text"><a-p>    </a-p><a-c>// the type of `args` is specific to `kind`. The actual running is handled by the client.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L375" href="#L375">375</a><span class="code-text"><a-p>    </a-p><a-pr>kind</a-pr><a-p>: </a-p><a-t>string</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L376" href="#L376">376</a><span class="code-text"><a-p>    </a-p><a-pr>args</a-pr><a-p>: </a-p><a-t>any</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L377" href="#L377">377</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L378" href="#L378">378</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L379" href="#L379">379</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L380" href="#L380">380</a><span class="code-text"><a-p>rust-analyzer supports only one `kind`, `&quot;cargo&quot;`. The `args` for `&quot;cargo&quot;` look like this:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L381" href="#L381">381</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L382" href="#L382">382</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L383" href="#L383">383</a><span class="code-text"><a-p>{</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L384" href="#L384">384</a><span class="code-text"><a-p>    </a-p><a-pr>workspaceRoot</a-pr><a-p>?: </a-p><a-v>string</a-v><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L385" href="#L385">385</a><span class="code-text"><a-p>    cargoArgs: </a-p><a-v>string</a-v><a-p>[</a-p><a-v>];</a-v></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L386" href="#L386">386</a><span class="code-text"><a-p>    cargoExtraArgs: </a-p><a-v>string</a-v><a-p>[</a-p><a-v>];</a-v></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L387" href="#L387">387</a><span class="code-text"><a-p>    executableArgs: </a-p><a-v>string</a-v><a-p>[</a-p><a-v>];</a-v></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L388" href="#L388">388</a><span class="code-text"><a-p>    expectTest?: </a-p><a-v>boolean</a-v><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L389" href="#L389">389</a><span class="code-text"><a-p>    overrideCargo?: </a-p><a-v>string</a-v><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L390" href="#L390">390</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L391" href="#L391">391</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L392" href="#L392">392</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L393" href="#L393">393</a><span class="code-text"><a-p>## </a-p><a-tt>Open External Documentation</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L394" href="#L394">394</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L395" href="#L395">395</a><span class="code-text"><a-p>This request is sent from client to server to get a URL to documentation for the symbol under the cursor, if available.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L396" href="#L396">396</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L397" href="#L397">397</a><span class="code-text"><a-p>**Method** `experimental/externalDocs`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L398" href="#L398">398</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L399" href="#L399">399</a><span class="code-text"><a-p>**Request:**: `TextDocumentPositionParams`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L400" href="#L400">400</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L401" href="#L401">401</a><span class="code-text"><a-p>**Response** `string | null`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L402" href="#L402">402</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L403" href="#L403">403</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L404" href="#L404">404</a><span class="code-text"><a-p>## </a-p><a-tt>Analyzer Status</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L405" href="#L405">405</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L406" href="#L406">406</a><span class="code-text"><a-p>**Method:** `rust-analyzer/analyzerStatus`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L407" href="#L407">407</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L408" href="#L408">408</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L409" href="#L409">409</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L410" href="#L410">410</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L411" href="#L411">411</a><span class="code-text"><a-p>interface </a-p><a-t>AnalyzerStatusParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L412" href="#L412">412</a><span class="code-text"><a-p>    </a-p><a-c>/// If specified, show dependencies of the current file.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L413" href="#L413">413</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>?: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L414" href="#L414">414</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L415" href="#L415">415</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L416" href="#L416">416</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L417" href="#L417">417</a><span class="code-text"><a-p>**Response:** `string`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L418" href="#L418">418</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L419" href="#L419">419</a><span class="code-text"><a-p>Returns internal status message, mostly for debugging purposes.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L420" href="#L420">420</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L421" href="#L421">421</a><span class="code-text"><a-p>## </a-p><a-tt>Reload Workspace</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L422" href="#L422">422</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L423" href="#L423">423</a><span class="code-text"><a-p>**Method:** `rust-analyzer/reloadWorkspace`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L424" href="#L424">424</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L425" href="#L425">425</a><span class="code-text"><a-p>**Request:** `null`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L426" href="#L426">426</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L427" href="#L427">427</a><span class="code-text"><a-p>**Response:** `null`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L428" href="#L428">428</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L429" href="#L429">429</a><span class="code-text"><a-p>Reloads project information (that is, re-executes `cargo metadata`).</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L430" href="#L430">430</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L431" href="#L431">431</a><span class="code-text"><a-p>## </a-p><a-tt>Server Status</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L432" href="#L432">432</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L433" href="#L433">433</a><span class="code-text"><a-p>**Experimental Client Capability:** `{ &quot;serverStatusNotification&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L434" href="#L434">434</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L435" href="#L435">435</a><span class="code-text"><a-p>**Method:** `experimental/serverStatus`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L436" href="#L436">436</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L437" href="#L437">437</a><span class="code-text"><a-p>**Notification:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L438" href="#L438">438</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L439" href="#L439">439</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L440" href="#L440">440</a><span class="code-text"><a-p>interface </a-p><a-t>ServerStatusParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L441" href="#L441">441</a><span class="code-text"><a-p>    </a-p><a-c>/// `ok` means that the server is completely functional.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L442" href="#L442">442</a><span class="code-text"><a-p>    </a-p><a-c>///</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L443" href="#L443">443</a><span class="code-text"><a-p>    </a-p><a-c>/// `warning` means that the server is partially functional.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L444" href="#L444">444</a><span class="code-text"><a-p>    </a-p><a-c>/// It can answer correctly to most requests, but some results</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L445" href="#L445">445</a><span class="code-text"><a-p>    </a-p><a-c>/// might be wrong due to, for example, some missing dependencies.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L446" href="#L446">446</a><span class="code-text"><a-p>    </a-p><a-c>///</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L447" href="#L447">447</a><span class="code-text"><a-p>    </a-p><a-c>/// `error` means that the server is not functional. For example,</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L448" href="#L448">448</a><span class="code-text"><a-p>    </a-p><a-c>/// there&#39;s a fatal build configuration problem. The server might</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L449" href="#L449">449</a><span class="code-text"><a-p>    </a-p><a-c>/// still give correct answers to simple requests, but most results</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L450" href="#L450">450</a><span class="code-text"><a-p>    </a-p><a-c>/// will be incomplete or wrong.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L451" href="#L451">451</a><span class="code-text"><a-p>    </a-p><a-pr>health</a-pr><a-p>: </a-p><a-s>&quot;ok&quot;</a-s><a-p> </a-p><a-o>|</a-o><a-p> </a-p><a-s>&quot;warning&quot;</a-s><a-p> </a-p><a-o>|</a-o><a-p> </a-p><a-s>&quot;error&quot;</a-s><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L452" href="#L452">452</a><span class="code-text"><a-p>    </a-p><a-c>/// Is there any pending background work which might change the status?</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L453" href="#L453">453</a><span class="code-text"><a-p>    </a-p><a-c>/// For example, are dependencies being downloaded?</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L454" href="#L454">454</a><span class="code-text"><a-p>    </a-p><a-pr>quiescent</a-pr><a-p>: </a-p><a-t>boolean</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L455" href="#L455">455</a><span class="code-text"><a-p>    </a-p><a-c>/// Explanatory message to show on hover.</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L456" href="#L456">456</a><span class="code-text"><a-p>    </a-p><a-pr>message</a-pr><a-p>?: </a-p><a-t>string</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L457" href="#L457">457</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L458" href="#L458">458</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L459" href="#L459">459</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L460" href="#L460">460</a><span class="code-text"><a-p>This notification is sent from server to client.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L461" href="#L461">461</a><span class="code-text"><a-p>The client can use it to display *persistent* status to the user (in modline).</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L462" href="#L462">462</a><span class="code-text"><a-p>It is similar to the `showMessage`, but is intended for stares rather than point-in-time events.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L463" href="#L463">463</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L464" href="#L464">464</a><span class="code-text"><a-p>Note that this functionality is intended primarily to inform the end user about the state of the server.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L465" href="#L465">465</a><span class="code-text"><a-p>In particular, it&#39;s valid for the client to completely ignore this extension.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L466" href="#L466">466</a><span class="code-text"><a-p>Clients are discouraged from but are allowed to use the `health` status to decide if it&#39;s worth sending a request to the server.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L467" href="#L467">467</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L468" href="#L468">468</a><span class="code-text"><a-p>## </a-p><a-tt>Syntax Tree</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L469" href="#L469">469</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L470" href="#L470">470</a><span class="code-text"><a-p>**Method:** `rust-analyzer/syntaxTree`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L471" href="#L471">471</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L472" href="#L472">472</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L473" href="#L473">473</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L474" href="#L474">474</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L475" href="#L475">475</a><span class="code-text"><a-p>interface </a-p><a-t>SyntaxTreeParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L476" href="#L476">476</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L477" href="#L477">477</a><span class="code-text"><a-p>    </a-p><a-pr>range</a-pr><a-p>?: </a-p><a-t>Range</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L478" href="#L478">478</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L479" href="#L479">479</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L480" href="#L480">480</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L481" href="#L481">481</a><span class="code-text"><a-p>**Response:** `string`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L482" href="#L482">482</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L483" href="#L483">483</a><span class="code-text"><a-p>Returns textual representation of a parse tree for the file/selected region.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L484" href="#L484">484</a><span class="code-text"><a-p>Primarily for debugging, but very useful for all people working on rust-analyzer itself.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L485" href="#L485">485</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L486" href="#L486">486</a><span class="code-text"><a-p>## </a-p><a-tt>View Hir</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L487" href="#L487">487</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L488" href="#L488">488</a><span class="code-text"><a-p>**Method:** `rust-analyzer/viewHir`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L489" href="#L489">489</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L490" href="#L490">490</a><span class="code-text"><a-p>**Request:** `TextDocumentPositionParams`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L491" href="#L491">491</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L492" href="#L492">492</a><span class="code-text"><a-p>**Response:** `string`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L493" href="#L493">493</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L494" href="#L494">494</a><span class="code-text"><a-p>Returns a textual representation of the HIR of the function containing the cursor.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L495" href="#L495">495</a><span class="code-text"><a-p>For debugging or when working on rust-analyzer itself.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L496" href="#L496">496</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L497" href="#L497">497</a><span class="code-text"><a-p>## </a-p><a-tt>View File Text</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L498" href="#L498">498</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L499" href="#L499">499</a><span class="code-text"><a-p>**Method:** `rust-analyzer/viewFileText`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L500" href="#L500">500</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L501" href="#L501">501</a><span class="code-text"><a-p>**Request:** `TextDocumentIdentifier`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L502" href="#L502">502</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L503" href="#L503">503</a><span class="code-text"><a-p>**Response:** `string`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L504" href="#L504">504</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L505" href="#L505">505</a><span class="code-text"><a-p>Returns the text of a file as seen by the server.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L506" href="#L506">506</a><span class="code-text"><a-p>This is for debugging file sync problems.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L507" href="#L507">507</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L508" href="#L508">508</a><span class="code-text"><a-p>## </a-p><a-tt>View ItemTree</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L509" href="#L509">509</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L510" href="#L510">510</a><span class="code-text"><a-p>**Method:** `rust-analyzer/viewItemTree`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L511" href="#L511">511</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L512" href="#L512">512</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L513" href="#L513">513</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L514" href="#L514">514</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L515" href="#L515">515</a><span class="code-text"><a-p>interface </a-p><a-t>ViewItemTreeParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L516" href="#L516">516</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L517" href="#L517">517</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L518" href="#L518">518</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L519" href="#L519">519</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L520" href="#L520">520</a><span class="code-text"><a-p>**Response:** `string`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L521" href="#L521">521</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L522" href="#L522">522</a><span class="code-text"><a-p>Returns a textual representation of the `ItemTree` of the currently open file, for debugging.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L523" href="#L523">523</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L524" href="#L524">524</a><span class="code-text"><a-p>## </a-p><a-tt>View Crate Graph</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L525" href="#L525">525</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L526" href="#L526">526</a><span class="code-text"><a-p>**Method:** `rust-analyzer/viewCrateGraph`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L527" href="#L527">527</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L528" href="#L528">528</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L529" href="#L529">529</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L530" href="#L530">530</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L531" href="#L531">531</a><span class="code-text"><a-p>interface </a-p><a-t>ViewCrateGraphParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L532" href="#L532">532</a><span class="code-text"><a-p>    </a-p><a-pr>full</a-pr><a-p>: </a-p><a-t>boolean</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L533" href="#L533">533</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L534" href="#L534">534</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L535" href="#L535">535</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L536" href="#L536">536</a><span class="code-text"><a-p>**Response:** `string`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L537" href="#L537">537</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L538" href="#L538">538</a><span class="code-text"><a-p>Renders rust-analyzer&#39;s crate graph as an SVG image.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L539" href="#L539">539</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L540" href="#L540">540</a><span class="code-text"><a-p>If `full` is `true`, the graph includes non-workspace crates (crates.io dependencies as well as sysroot crates).</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L541" href="#L541">541</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L542" href="#L542">542</a><span class="code-text"><a-p>## </a-p><a-tt>Shuffle Crate Graph</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L543" href="#L543">543</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L544" href="#L544">544</a><span class="code-text"><a-p>**Method:** `rust-analyzer/shuffleCrateGraph`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L545" href="#L545">545</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L546" href="#L546">546</a><span class="code-text"><a-p>**Request:** `null`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L547" href="#L547">547</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L548" href="#L548">548</a><span class="code-text"><a-p>Shuffles the crate IDs in the crate graph, for debugging purposes.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L549" href="#L549">549</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L550" href="#L550">550</a><span class="code-text"><a-p>## </a-p><a-tt>Expand Macro</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L551" href="#L551">551</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L552" href="#L552">552</a><span class="code-text"><a-p>**Method:** `rust-analyzer/expandMacro`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L553" href="#L553">553</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L554" href="#L554">554</a><span class="code-text"><a-p>**Request:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L555" href="#L555">555</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L556" href="#L556">556</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L557" href="#L557">557</a><span class="code-text"><a-p>interface </a-p><a-t>ExpandMacroParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L558" href="#L558">558</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L559" href="#L559">559</a><span class="code-text"><a-p>    </a-p><a-pr>position</a-pr><a-p>: </a-p><a-t>Position</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L560" href="#L560">560</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L561" href="#L561">561</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L562" href="#L562">562</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L563" href="#L563">563</a><span class="code-text"><a-p>**Response:**</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L564" href="#L564">564</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L565" href="#L565">565</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L566" href="#L566">566</a><span class="code-text"><a-p>interface </a-p><a-t>ExpandedMacro</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L567" href="#L567">567</a><span class="code-text"><a-p>    </a-p><a-pr>name</a-pr><a-p>: </a-p><a-t>string</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L568" href="#L568">568</a><span class="code-text"><a-p>    </a-p><a-pr>expansion</a-pr><a-p>: </a-p><a-t>string</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L569" href="#L569">569</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L570" href="#L570">570</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L571" href="#L571">571</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L572" href="#L572">572</a><span class="code-text"><a-p>Expands macro call at a given position.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L573" href="#L573">573</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L574" href="#L574">574</a><span class="code-text"><a-p>## </a-p><a-tt>Hover Actions</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L575" href="#L575">575</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L576" href="#L576">576</a><span class="code-text"><a-p>**Experimental Client Capability:** `{ &quot;hoverActions&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L577" href="#L577">577</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L578" href="#L578">578</a><span class="code-text"><a-p>If this capability is set, `Hover` request returned from the server might contain an additional field, `actions`:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L579" href="#L579">579</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L580" href="#L580">580</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L581" href="#L581">581</a><span class="code-text"><a-p>interface </a-p><a-t>Hover</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L582" href="#L582">582</a><span class="code-text"><a-p>    ...</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L583" href="#L583">583</a><span class="code-text"><a-p>    </a-p><a-pr>actions</a-pr><a-p>?: </a-p><a-t>CommandLinkGroup</a-t><a-p>[];</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L584" href="#L584">584</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L585" href="#L585">585</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L586" href="#L586">586</a><span class="code-text"><a-p>interface </a-p><a-t>CommandLink</a-t><a-p> </a-p><a-k>extends</a-k><a-p> </a-p><a-t>Command</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L587" href="#L587">587</a><span class="code-text"><a-p>    </a-p><a-c>/**</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L588" href="#L588">588</a><span class="code-text"><a-p>     * A tooltip for the command, when represented in the UI.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L589" href="#L589">589</a><span class="code-text"><a-p>     */</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L590" href="#L590">590</a><span class="code-text"><a-p>    </a-p><a-pr>tooltip</a-pr><a-p>?: </a-p><a-t>string</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L591" href="#L591">591</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L592" href="#L592">592</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L593" href="#L593">593</a><span class="code-text"><a-p>interface </a-p><a-t>CommandLinkGroup</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L594" href="#L594">594</a><span class="code-text"><a-p>    </a-p><a-pr>title</a-pr><a-p>?: </a-p><a-t>string</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L595" href="#L595">595</a><span class="code-text"><a-p>    </a-p><a-pr>commands</a-pr><a-p>: </a-p><a-t>CommandLink</a-t><a-p>[];</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L596" href="#L596">596</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L597" href="#L597">597</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L598" href="#L598">598</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L599" href="#L599">599</a><span class="code-text"><a-p>Such actions on the client side are appended to a hover bottom as command links:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L600" href="#L600">600</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L601" href="#L601">601</a><span class="code-text"><a-p>  +-----------------------------+</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L602" href="#L602">602</a><span class="code-text"><a-p>  | Hover content               |</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L603" href="#L603">603</a><span class="code-text"><a-p>  |                             |</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L604" href="#L604">604</a><span class="code-text"><a-p>  +-----------------------------+</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L605" href="#L605">605</a><span class="code-text"><a-p>  | _Action1_ | _Action2_       |  &lt;- first group, no TITLE</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L606" href="#L606">606</a><span class="code-text"><a-p>  +-----------------------------+</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L607" href="#L607">607</a><span class="code-text"><a-p>  | TITLE _Action1_ | _Action2_ |  &lt;- second group</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L608" href="#L608">608</a><span class="code-text"><a-p>  +-----------------------------+</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L609" href="#L609">609</a><span class="code-text"><a-p>  ...</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L610" href="#L610">610</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L611" href="#L611">611</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L612" href="#L612">612</a><span class="code-text"><a-p>## </a-p><a-tt>Open Cargo.toml</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L613" href="#L613">613</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L614" href="#L614">614</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/rust-analyzer/rust-analyzer/issues/6462</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L615" href="#L615">615</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L616" href="#L616">616</a><span class="code-text"><a-p>**Experimental Server Capability:** `{ &quot;openCargoToml&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L617" href="#L617">617</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L618" href="#L618">618</a><span class="code-text"><a-p>This request is sent from client to server to open the current project&#39;s Cargo.toml</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L619" href="#L619">619</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L620" href="#L620">620</a><span class="code-text"><a-p>**Method:** `experimental/openCargoToml`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L621" href="#L621">621</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L622" href="#L622">622</a><span class="code-text"><a-p>**Request:** `OpenCargoTomlParams`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L623" href="#L623">623</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L624" href="#L624">624</a><span class="code-text"><a-p>**Response:** `Location | null`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L625" href="#L625">625</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L626" href="#L626">626</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L627" href="#L627">627</a><span class="code-text"><a-p>### </a-p><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L628" href="#L628">628</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L629" href="#L629">629</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L630" href="#L630">630</a><span class="code-text"><a-p>// Cargo.toml</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L631" href="#L631">631</a><span class="code-text"><a-p>[package]</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L632" href="#L632">632</a><span class="code-text"><a-p>// src/main.rs</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L633" href="#L633">633</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L634" href="#L634">634</a><span class="code-text"><a-p>/* cursor here*/</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L635" href="#L635">635</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L636" href="#L636">636</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L637" href="#L637">637</a><span class="code-text"><a-p>`experimental/openCargoToml` returns a single `Link` to the start of the `[package]` keyword.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L638" href="#L638">638</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L639" href="#L639">639</a><span class="code-text"><a-p>## </a-p><a-tt>Related tests</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L640" href="#L640">640</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L641" href="#L641">641</a><span class="code-text"><a-p>This request is sent from client to server to get the list of tests for the specified position.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L642" href="#L642">642</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L643" href="#L643">643</a><span class="code-text"><a-p>**Method:** `rust-analyzer/relatedTests`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L644" href="#L644">644</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L645" href="#L645">645</a><span class="code-text"><a-p>**Request:** `TextDocumentPositionParams`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L646" href="#L646">646</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L647" href="#L647">647</a><span class="code-text"><a-p>**Response:** `TestInfo[]`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L648" href="#L648">648</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L649" href="#L649">649</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L650" href="#L650">650</a><span class="code-text"><a-p>interface </a-p><a-t>TestInfo</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L651" href="#L651">651</a><span class="code-text"><a-p>    </a-p><a-pr>runnable</a-pr><a-p>: </a-p><a-t>Runnable</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L652" href="#L652">652</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L653" href="#L653">653</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L654" href="#L654">654</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L655" href="#L655">655</a><span class="code-text"><a-p>## </a-p><a-tt>Hover Range</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L656" href="#L656">656</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L657" href="#L657">657</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/377</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L658" href="#L658">658</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L659" href="#L659">659</a><span class="code-text"><a-p>**Experimental Server Capability:** { &quot;hoverRange&quot;: boolean }</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L660" href="#L660">660</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L661" href="#L661">661</a><span class="code-text"><a-p>This extension allows passing a `Range` as a `position` field of `HoverParams`.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L662" href="#L662">662</a><span class="code-text"><a-p>The primary use-case is to use the hover request to show the type of the expression currently selected.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L663" href="#L663">663</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L664" href="#L664">664</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L665" href="#L665">665</a><span class="code-text"><a-p>interface </a-p><a-t>HoverParams</a-t><a-p> </a-p><a-k>extends</a-k><a-p> </a-p><a-t>WorkDoneProgressParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L666" href="#L666">666</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L667" href="#L667">667</a><span class="code-text"><a-p>    </a-p><a-pr>position</a-pr><a-p>: </a-p><a-t>Range</a-t><a-p> </a-p><a-o>|</a-o><a-p> </a-p><a-t>Position</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L668" href="#L668">668</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L669" href="#L669">669</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L670" href="#L670">670</a><span class="code-text"><a-p>Whenever the client sends a `Range`, it is understood as the current selection and any hover included in the range will show the type of the expression if possible.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L671" href="#L671">671</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L672" href="#L672">672</a><span class="code-text"><a-p>### </a-p><a-tt>Example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L673" href="#L673">673</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L674" href="#L674">674</a><span class="code-text"><a-p>```</a-p><a-tl>rust</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L675" href="#L675">675</a><span class="code-text"><a-p>fn </a-p><a-f>main</a-f><a-p>() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L676" href="#L676">676</a><span class="code-text"><a-p>    </a-p><a-k>let</a-k><a-p> expression = $</a-p><a-co>01</a-co><a-p> + </a-p><a-co>2</a-co><a-p> </a-p><a-o>*</a-o><a-p> </a-p><a-co>3</a-co><a-p>$</a-p><a-co>0</a-co><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L677" href="#L677">677</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L678" href="#L678">678</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L679" href="#L679">679</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L680" href="#L680">680</a><span class="code-text"><a-p>Triggering a hover inside the selection above will show a result of `i32`.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L681" href="#L681">681</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L682" href="#L682">682</a><span class="code-text"><a-p>## </a-p><a-tt>Move Item</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L683" href="#L683">683</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L684" href="#L684">684</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/rust-analyzer/rust-analyzer/issues/6823</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L685" href="#L685">685</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L686" href="#L686">686</a><span class="code-text"><a-p>This request is sent from client to server to move item under cursor or selection in some direction.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L687" href="#L687">687</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L688" href="#L688">688</a><span class="code-text"><a-p>**Method:** `experimental/moveItem`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L689" href="#L689">689</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L690" href="#L690">690</a><span class="code-text"><a-p>**Request:** `MoveItemParams`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L691" href="#L691">691</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L692" href="#L692">692</a><span class="code-text"><a-p>**Response:** `SnippetTextEdit[]`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L693" href="#L693">693</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L694" href="#L694">694</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L695" href="#L695">695</a><span class="code-text"><a-p>export </a-p><a-k>interface</a-k><a-p> </a-p><a-t>MoveItemParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L696" href="#L696">696</a><span class="code-text"><a-p>    </a-p><a-pr>textDocument</a-pr><a-p>: </a-p><a-t>TextDocumentIdentifier</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L697" href="#L697">697</a><span class="code-text"><a-p>    </a-p><a-pr>range</a-pr><a-p>: </a-p><a-t>Range</a-t><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L698" href="#L698">698</a><span class="code-text"><a-p>    </a-p><a-pr>direction</a-pr><a-p>: </a-p><a-t>Direction</a-t></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L699" href="#L699">699</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L700" href="#L700">700</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L701" href="#L701">701</a><span class="code-text"><a-p>export </a-p><a-k>const</a-k><a-p> </a-p><a-k>enum</a-k><a-p> </a-p><a-t>Direction</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L702" href="#L702">702</a><span class="code-text"><a-p>    </a-p><a-pr>Up</a-pr><a-p> </a-p><a-o>=</a-o><a-p> </a-p><a-s>&quot;Up&quot;</a-s><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L703" href="#L703">703</a><span class="code-text"><a-p>    </a-p><a-pr>Down</a-pr><a-p> </a-p><a-o>=</a-o><a-p> </a-p><a-s>&quot;Down&quot;</a-s></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L704" href="#L704">704</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L705" href="#L705">705</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L706" href="#L706">706</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L707" href="#L707">707</a><span class="code-text"><a-p>## </a-p><a-tt>Workspace Symbols Filtering</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L708" href="#L708">708</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L709" href="#L709">709</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/941</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L710" href="#L710">710</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L711" href="#L711">711</a><span class="code-text"><a-p>**Experimental Server Capability:** `{ &quot;workspaceSymbolScopeKindFiltering&quot;: boolean }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L712" href="#L712">712</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L713" href="#L713">713</a><span class="code-text"><a-p>Extends the existing `workspace/symbol` request with ability to filter symbols by broad scope and kind of symbol.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L714" href="#L714">714</a><span class="code-text"><a-p>If this capability is set, `workspace/symbol` parameter gains two new optional fields:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L715" href="#L715">715</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L716" href="#L716">716</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L717" href="#L717">717</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L718" href="#L718">718</a><span class="code-text"><a-p>interface </a-p><a-t>WorkspaceSymbolParams</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L719" href="#L719">719</a><span class="code-text"><a-p>    </a-p><a-c>/**</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L720" href="#L720">720</a><span class="code-text"><a-p>     * Return only the symbols defined in the specified scope.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L721" href="#L721">721</a><span class="code-text"><a-p>     */</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L722" href="#L722">722</a><span class="code-text"><a-p>    </a-p><a-pr>searchScope</a-pr><a-p>?: </a-p><a-t>WorkspaceSymbolSearchScope</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L723" href="#L723">723</a><span class="code-text"><a-p>    </a-p><a-c>/**</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L724" href="#L724">724</a><span class="code-text"><a-p>     * Return only the symbols of specified kinds.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L725" href="#L725">725</a><span class="code-text"><a-p>     */</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L726" href="#L726">726</a><span class="code-text"><a-p>    </a-p><a-pr>searchKind</a-pr><a-p>?: </a-p><a-t>WorkspaceSymbolSearchKind</a-t><a-p>;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L727" href="#L727">727</a><span class="code-text"><a-p>    ...</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L728" href="#L728">728</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L729" href="#L729">729</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L730" href="#L730">730</a><span class="code-text"><a-p>const </a-p><a-k>enum</a-k><a-p> </a-p><a-t>WorkspaceSymbolSearchScope</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L731" href="#L731">731</a><span class="code-text"><a-p>    </a-p><a-pr>Workspace</a-pr><a-p> </a-p><a-o>=</a-o><a-p> </a-p><a-s>&quot;workspace&quot;</a-s><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L732" href="#L732">732</a><span class="code-text"><a-p>    </a-p><a-pr>WorkspaceAndDependencies</a-pr><a-p> </a-p><a-o>=</a-o><a-p> </a-p><a-s>&quot;workspaceAndDependencies&quot;</a-s></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L733" href="#L733">733</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L734" href="#L734">734</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L735" href="#L735">735</a><span class="code-text"><a-p>const </a-p><a-k>enum</a-k><a-p> </a-p><a-t>WorkspaceSymbolSearchKind</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L736" href="#L736">736</a><span class="code-text"><a-p>    </a-p><a-pr>OnlyTypes</a-pr><a-p> </a-p><a-o>=</a-o><a-p> </a-p><a-s>&quot;onlyTypes&quot;</a-s><a-p>,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L737" href="#L737">737</a><span class="code-text"><a-p>    </a-p><a-pr>AllSymbols</a-pr><a-p> </a-p><a-o>=</a-o><a-p> </a-p><a-s>&quot;allSymbols&quot;</a-s></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L738" href="#L738">738</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L739" href="#L739">739</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L740" href="#L740">740</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L741" href="#L741">741</a><span class="code-text"><a-p>## </a-p><a-tt>Client Commands</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L742" href="#L742">742</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L743" href="#L743">743</a><span class="code-text"><a-p>**Upstream Issue:** https://github.com/microsoft/language-server-protocol/issues/642</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L744" href="#L744">744</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L745" href="#L745">745</a><span class="code-text"><a-p>**Experimental Client Capability:** `{ &quot;commands?&quot;: ClientCommandOptions }`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L746" href="#L746">746</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L747" href="#L747">747</a><span class="code-text"><a-p>Certain LSP types originating on the server, notably code lenses, embed commands.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L748" href="#L748">748</a><span class="code-text"><a-p>Commands can be serviced either by the server or by the client.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L749" href="#L749">749</a><span class="code-text"><a-p>However, the server doesn&#39;t know which commands are available on the client.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L750" href="#L750">750</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L751" href="#L751">751</a><span class="code-text"><a-p>This extensions allows the client to communicate this info.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L752" href="#L752">752</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L753" href="#L753">753</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L754" href="#L754">754</a><span class="code-text"><a-p>```</a-p><a-tl>typescript</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L755" href="#L755">755</a><span class="code-text"><a-p>export </a-p><a-k>interface</a-k><a-p> </a-p><a-t>ClientCommandOptions</a-t><a-p> {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L756" href="#L756">756</a><span class="code-text"><a-p>    </a-p><a-c>/**</a-c></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L757" href="#L757">757</a><span class="code-text"><a-p>     * The commands to be executed on the client</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L758" href="#L758">758</a><span class="code-text"><a-p>     */</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L759" href="#L759">759</a><span class="code-text"><a-p>    </a-p><a-pr>commands</a-pr><a-p>: </a-p><a-t>string</a-t><a-p>[];</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L760" href="#L760">760</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L761" href="#L761">761</a><span class="code-text"><a-p>```</a-p></span></span></pre></div></div>
</main>
</body>
</html>
