forked from Mirrors/helix
commit
c3c50517ee
GPG Key ID:
DFFFCC2C7A02DB45
@ -0,0 +1,75 @@
|
||||
| Name | Description |
|
||||
| --- | --- |
|
||||
| `:quit`, `:q` | Close the current view. |
|
||||
| `:quit!`, `:q!` | Close the current view forcefully (ignoring unsaved changes). |
|
||||
| `:open`, `:o` | Open a file from disk into the current view. |
|
||||
| `:buffer-close`, `:bc`, `:bclose` | Close the current buffer. |
|
||||
| `:buffer-close!`, `:bc!`, `:bclose!` | Close the current buffer forcefully (ignoring unsaved changes). |
|
||||
| `:buffer-close-others`, `:bco`, `:bcloseother` | Close all buffers but the currently focused one. |
|
||||
| `:buffer-close-others!`, `:bco!`, `:bcloseother!` | Close all buffers but the currently focused one. |
|
||||
| `:buffer-close-all`, `:bca`, `:bcloseall` | Close all buffers, without quitting. |
|
||||
| `:buffer-close-all!`, `:bca!`, `:bcloseall!` | Close all buffers forcefully (ignoring unsaved changes), without quitting. |
|
||||
| `:buffer-next`, `:bn`, `:bnext` | Go to next buffer. |
|
||||
| `:buffer-previous`, `:bp`, `:bprev` | Go to previous buffer. |
|
||||
| `:write`, `:w` | Write changes to disk. Accepts an optional path (:write some/path.txt) |
|
||||
| `:write!`, `:w!` | Write changes to disk forcefully (creating necessary subdirectories). Accepts an optional path (:write some/path.txt) |
|
||||
| `:new`, `:n` | Create a new scratch buffer. |
|
||||
| `:format`, `:fmt` | Format the file using the LSP formatter. |
|
||||
| `:indent-style` | Set the indentation style for editing. ('t' for tabs or 1-8 for number of spaces.) |
|
||||
| `:line-ending` | Set the document's default line ending. Options: crlf, lf. |
|
||||
| `:earlier`, `:ear` | Jump back to an earlier point in edit history. Accepts a number of steps or a time span. |
|
||||
| `:later`, `:lat` | Jump to a later point in edit history. Accepts a number of steps or a time span. |
|
||||
| `:write-quit`, `:wq`, `:x` | Write changes to disk and close the current view. Accepts an optional path (:wq some/path.txt) |
|
||||
| `:write-quit!`, `:wq!`, `:x!` | Write changes to disk and close the current view forcefully. Accepts an optional path (:wq! some/path.txt) |
|
||||
| `:write-all`, `:wa` | Write changes from all buffers to disk. |
|
||||
| `:write-quit-all`, `:wqa`, `:xa` | Write changes from all buffers to disk and close all views. |
|
||||
| `:write-quit-all!`, `:wqa!`, `:xa!` | Write changes from all buffers to disk and close all views forcefully (ignoring unsaved changes). |
|
||||
| `:quit-all`, `:qa` | Close all views. |
|
||||
| `:quit-all!`, `:qa!` | Close all views forcefully (ignoring unsaved changes). |
|
||||
| `:cquit`, `:cq` | Quit with exit code (default 1). Accepts an optional integer exit code (:cq 2). |
|
||||
| `:cquit!`, `:cq!` | Quit with exit code (default 1) forcefully (ignoring unsaved changes). Accepts an optional integer exit code (:cq! 2). |
|
||||
| `:theme` | Change the editor theme. |
|
||||
| `:clipboard-yank` | Yank main selection into system clipboard. |
|
||||
| `:clipboard-yank-join` | Yank joined selections into system clipboard. A separator can be provided as first argument. Default value is newline. |
|
||||
| `:primary-clipboard-yank` | Yank main selection into system primary clipboard. |
|
||||
| `:primary-clipboard-yank-join` | Yank joined selections into system primary clipboard. A separator can be provided as first argument. Default value is newline. |
|
||||
| `:clipboard-paste-after` | Paste system clipboard after selections. |
|
||||
| `:clipboard-paste-before` | Paste system clipboard before selections. |
|
||||
| `:clipboard-paste-replace` | Replace selections with content of system clipboard. |
|
||||
| `:primary-clipboard-paste-after` | Paste primary clipboard after selections. |
|
||||
| `:primary-clipboard-paste-before` | Paste primary clipboard before selections. |
|
||||
| `:primary-clipboard-paste-replace` | Replace selections with content of system primary clipboard. |
|
||||
| `:show-clipboard-provider` | Show clipboard provider name in status bar. |
|
||||
| `:change-current-directory`, `:cd` | Change the current working directory. |
|
||||
| `:show-directory`, `:pwd` | Show the current working directory. |
|
||||
| `:encoding` | Set encoding based on `https://encoding.spec.whatwg.org` |
|
||||
| `:reload` | Discard changes and reload from the source file. |
|
||||
| `:tree-sitter-scopes` | Display tree sitter scopes, primarily for theming and development. |
|
||||
| `:debug-start`, `:dbg` | Start a debug session from a given template with given parameters. |
|
||||
| `:debug-remote`, `:dbg-tcp` | Connect to a debug adapter by TCP address and start a debugging session from a given template with given parameters. |
|
||||
| `:debug-eval` | Evaluate expression in current debug context. |
|
||||
| `:vsplit`, `:vs` | Open the file in a vertical split. |
|
||||
| `:vsplit-new`, `:vnew` | Open a scratch buffer in a vertical split. |
|
||||
| `:hsplit`, `:hs`, `:sp` | Open the file in a horizontal split. |
|
||||
| `:hsplit-new`, `:hnew` | Open a scratch buffer in a horizontal split. |
|
||||
| `:tutor` | Open the tutorial. |
|
||||
| `:goto`, `:g` | Go to line number. |
|
||||
| `:set-language`, `:lang` | Set the language of current buffer. |
|
||||
| `:set-option`, `:set` | Set a config option at runtime.<br>For example to disable smart case search, use `:set search.smart-case false`. |
|
||||
| `:get-option`, `:get` | Get the current value of a config option. |
|
||||
| `:sort` | Sort ranges in selection. |
|
||||
| `:rsort` | Sort ranges in selection in reverse order. |
|
||||
| `:reflow` | Hard-wrap the current selection of lines to a given width. |
|
||||
| `:tree-sitter-subtree`, `:ts-subtree` | Display tree sitter subtree under cursor, primarily for debugging queries. |
|
||||
| `:config-reload` | Refreshes helix's config. |
|
||||
| `:config-open` | Open the helix config.toml file. |
|
||||
| `:log-open` | Open the helix log file. |
|
||||
| `:insert-output` | Run shell command, inserting output after each selection. |
|
||||
| `:append-output` | Run shell command, appending output after each selection. |
|
||||
| `:pipe` | Pipe each selection to the shell command. |
|
||||
<<<<<<< HEAD
|
||||
| `:run-shell-command`, `:sh` | Run a shell command |
|
||||
||||||| 4b1fe367
|
||||
=======
|
||||
| `:lsp-restart` | Restarts the LSP server of the current buffer |
|
||||
>>>>>>> lsp-restart
|
||||
@ -0,0 +1,621 @@
|
||||
mod client;
|
||||
pub mod jsonrpc;
|
||||
mod transport;
|
||||
|
||||
pub use client::Client;
|
||||
pub use futures_executor::block_on;
|
||||
pub use jsonrpc::Call;
|
||||
pub use lsp::{Position, Url};
|
||||
pub use lsp_types as lsp;
|
||||
|
||||
use futures_util::stream::select_all::SelectAll;
|
||||
use helix_core::syntax::LanguageConfiguration;
|
||||
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
sync::{
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
Arc,
|
||||
},
|
||||
};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use thiserror::Error;
|
||||
use tokio_stream::wrappers::UnboundedReceiverStream;
|
||||
|
||||
pub type Result<T> = core::result::Result<T, Error>;
|
||||
type LanguageId = String;
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum Error {
|
||||
#[error("protocol error: {0}")]
|
||||
Rpc(#[from] jsonrpc::Error),
|
||||
#[error("failed to parse: {0}")]
|
||||
Parse(#[from] serde_json::Error),
|
||||
#[error("IO Error: {0}")]
|
||||
IO(#[from] std::io::Error),
|
||||
#[error("request timed out")]
|
||||
Timeout,
|
||||
#[error("server closed the stream")]
|
||||
StreamClosed,
|
||||
#[error("LSP not defined")]
|
||||
LspNotDefined,
|
||||
#[error("Unhandled")]
|
||||
Unhandled,
|
||||
#[error(transparent)]
|
||||
Other(#[from] anyhow::Error),
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
|
||||
pub enum OffsetEncoding {
|
||||
/// UTF-8 code units aka bytes
|
||||
#[serde(rename = "utf-8")]
|
||||
Utf8,
|
||||
/// UTF-16 code units
|
||||
#[serde(rename = "utf-16")]
|
||||
Utf16,
|
||||
}
|
||||
|
||||
pub mod util {
|
||||
use super::*;
|
||||
use helix_core::{Range, Rope, Transaction};
|
||||
|
||||
/// Converts a diagnostic in the document to [`lsp::Diagnostic`].
|
||||
///
|
||||
/// Panics when [`pos_to_lsp_pos`] would for an invalid range on the diagnostic.
|
||||
pub fn diagnostic_to_lsp_diagnostic(
|
||||
doc: &Rope,
|
||||
diag: &helix_core::diagnostic::Diagnostic,
|
||||
offset_encoding: OffsetEncoding,
|
||||
) -> lsp::Diagnostic {
|
||||
use helix_core::diagnostic::Severity::*;
|
||||
|
||||
let range = Range::new(diag.range.start, diag.range.end);
|
||||
let severity = diag.severity.map(|s| match s {
|
||||
Hint => lsp::DiagnosticSeverity::HINT,
|
||||
Info => lsp::DiagnosticSeverity::INFORMATION,
|
||||
Warning => lsp::DiagnosticSeverity::WARNING,
|
||||
Error => lsp::DiagnosticSeverity::ERROR,
|
||||
});
|
||||
|
||||
// TODO: add support for Diagnostic.data
|
||||
lsp::Diagnostic::new(
|
||||
range_to_lsp_range(doc, range, offset_encoding),
|
||||
severity,
|
||||
None,
|
||||
None,
|
||||
diag.message.to_owned(),
|
||||
None,
|
||||
None,
|
||||
)
|
||||
}
|
||||
|
||||
/// Converts [`lsp::Position`] to a position in the document.
|
||||
///
|
||||
/// Returns `None` if position exceeds document length or an operation overflows.
|
||||
pub fn lsp_pos_to_pos(
|
||||
doc: &Rope,
|
||||
pos: lsp::Position,
|
||||
offset_encoding: OffsetEncoding,
|
||||
) -> Option<usize> {
|
||||
let pos_line = pos.line as usize;
|
||||
if pos_line > doc.len_lines() - 1 {
|
||||
return None;
|
||||
}
|
||||
|
||||
match offset_encoding {
|
||||
OffsetEncoding::Utf8 => {
|
||||
let line = doc.line_to_char(pos_line);
|
||||
let pos = line.checked_add(pos.character as usize)?;
|
||||
if pos <= doc.len_chars() {
|
||||
Some(pos)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
OffsetEncoding::Utf16 => {
|
||||
let line = doc.line_to_char(pos_line);
|
||||
let line_start = doc.char_to_utf16_cu(line);
|
||||
let pos = line_start.checked_add(pos.character as usize)?;
|
||||
doc.try_utf16_cu_to_char(pos).ok()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Converts position in the document to [`lsp::Position`].
|
||||
///
|
||||
/// Panics when `pos` is out of `doc` bounds or operation overflows.
|
||||
pub fn pos_to_lsp_pos(
|
||||
doc: &Rope,
|
||||
pos: usize,
|
||||
offset_encoding: OffsetEncoding,
|
||||
) -> lsp::Position {
|
||||
match offset_encoding {
|
||||
OffsetEncoding::Utf8 => {
|
||||
let line = doc.char_to_line(pos);
|
||||
let line_start = doc.line_to_char(line);
|
||||
let col = pos - line_start;
|
||||
|
||||
lsp::Position::new(line as u32, col as u32)
|
||||
}
|
||||
OffsetEncoding::Utf16 => {
|
||||
let line = doc.char_to_line(pos);
|
||||
let line_start = doc.char_to_utf16_cu(doc.line_to_char(line));
|
||||
let col = doc.char_to_utf16_cu(pos) - line_start;
|
||||
|
||||
lsp::Position::new(line as u32, col as u32)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Converts a range in the document to [`lsp::Range`].
|
||||
pub fn range_to_lsp_range(
|
||||
doc: &Rope,
|
||||
range: Range,
|
||||
offset_encoding: OffsetEncoding,
|
||||
) -> lsp::Range {
|
||||
let start = pos_to_lsp_pos(doc, range.from(), offset_encoding);
|
||||
let end = pos_to_lsp_pos(doc, range.to(), offset_encoding);
|
||||
|
||||
lsp::Range::new(start, end)
|
||||
}
|
||||
|
||||
pub fn lsp_range_to_range(
|
||||
doc: &Rope,
|
||||
range: lsp::Range,
|
||||
offset_encoding: OffsetEncoding,
|
||||
) -> Option<Range> {
|
||||
let start = lsp_pos_to_pos(doc, range.start, offset_encoding)?;
|
||||
let end = lsp_pos_to_pos(doc, range.end, offset_encoding)?;
|
||||
|
||||
Some(Range::new(start, end))
|
||||
}
|
||||
|
||||
pub fn generate_transaction_from_edits(
|
||||
doc: &Rope,
|
||||
mut edits: Vec<lsp::TextEdit>,
|
||||
offset_encoding: OffsetEncoding,
|
||||
) -> Transaction {
|
||||
// Sort edits by start range, since some LSPs (Omnisharp) send them
|
||||
// in reverse order.
|
||||
edits.sort_unstable_by_key(|edit| edit.range.start);
|
||||
|
||||
Transaction::change(
|
||||
doc,
|
||||
edits.into_iter().map(|edit| {
|
||||
// simplify "" into None for cleaner changesets
|
||||
let replacement = if !edit.new_text.is_empty() {
|
||||
Some(edit.new_text.into())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let start =
|
||||
if let Some(start) = lsp_pos_to_pos(doc, edit.range.start, offset_encoding) {
|
||||
start
|
||||
} else {
|
||||
return (0, 0, None);
|
||||
};
|
||||
let end = if let Some(end) = lsp_pos_to_pos(doc, edit.range.end, offset_encoding) {
|
||||
end
|
||||
} else {
|
||||
return (0, 0, None);
|
||||
};
|
||||
(start, end, replacement)
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
||||
/// The result of asking the language server to format the document. This can be turned into a
|
||||
/// `Transaction`, but the advantage of not doing that straight away is that this one is
|
||||
/// `Send` and `Sync`.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LspFormatting {
|
||||
pub doc: Rope,
|
||||
pub edits: Vec<lsp::TextEdit>,
|
||||
pub offset_encoding: OffsetEncoding,
|
||||
}
|
||||
|
||||
impl From<LspFormatting> for Transaction {
|
||||
fn from(fmt: LspFormatting) -> Transaction {
|
||||
generate_transaction_from_edits(&fmt.doc, fmt.edits, fmt.offset_encoding)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum MethodCall {
|
||||
WorkDoneProgressCreate(lsp::WorkDoneProgressCreateParams),
|
||||
ApplyWorkspaceEdit(lsp::ApplyWorkspaceEditParams),
|
||||
WorkspaceFolders,
|
||||
WorkspaceConfiguration(lsp::ConfigurationParams),
|
||||
}
|
||||
|
||||
impl MethodCall {
|
||||
pub fn parse(method: &str, params: jsonrpc::Params) -> Result<MethodCall> {
|
||||
use lsp::request::Request;
|
||||
let request = match method {
|
||||
lsp::request::WorkDoneProgressCreate::METHOD => {
|
||||
let params: lsp::WorkDoneProgressCreateParams = params.parse()?;
|
||||
Self::WorkDoneProgressCreate(params)
|
||||
}
|
||||
lsp::request::ApplyWorkspaceEdit::METHOD => {
|
||||
let params: lsp::ApplyWorkspaceEditParams = params.parse()?;
|
||||
Self::ApplyWorkspaceEdit(params)
|
||||
}
|
||||
lsp::request::WorkspaceFoldersRequest::METHOD => Self::WorkspaceFolders,
|
||||
lsp::request::WorkspaceConfiguration::METHOD => {
|
||||
let params: lsp::ConfigurationParams = params.parse()?;
|
||||
Self::WorkspaceConfiguration(params)
|
||||
}
|
||||
_ => {
|
||||
return Err(Error::Unhandled);
|
||||
}
|
||||
};
|
||||
Ok(request)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum Notification {
|
||||
// we inject this notification to signal the LSP is ready
|
||||
Initialized,
|
||||
PublishDiagnostics(lsp::PublishDiagnosticsParams),
|
||||
ShowMessage(lsp::ShowMessageParams),
|
||||
LogMessage(lsp::LogMessageParams),
|
||||
ProgressMessage(lsp::ProgressParams),
|
||||
}
|
||||
|
||||
impl Notification {
|
||||
pub fn parse(method: &str, params: jsonrpc::Params) -> Result<Notification> {
|
||||
use lsp::notification::Notification as _;
|
||||
|
||||
let notification = match method {
|
||||
lsp::notification::Initialized::METHOD => Self::Initialized,
|
||||
lsp::notification::PublishDiagnostics::METHOD => {
|
||||
let params: lsp::PublishDiagnosticsParams = params.parse()?;
|
||||
Self::PublishDiagnostics(params)
|
||||
}
|
||||
|
||||
lsp::notification::ShowMessage::METHOD => {
|
||||
let params: lsp::ShowMessageParams = params.parse()?;
|
||||
Self::ShowMessage(params)
|
||||
}
|
||||
lsp::notification::LogMessage::METHOD => {
|
||||
let params: lsp::LogMessageParams = params.parse()?;
|
||||
Self::LogMessage(params)
|
||||
}
|
||||
lsp::notification::Progress::METHOD => {
|
||||
let params: lsp::ProgressParams = params.parse()?;
|
||||
Self::ProgressMessage(params)
|
||||
}
|
||||
_ => {
|
||||
return Err(Error::Unhandled);
|
||||
}
|
||||
};
|
||||
|
||||
Ok(notification)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Registry {
|
||||
inner: HashMap<LanguageId, (usize, Arc<Client>)>,
|
||||
|
||||
counter: AtomicUsize,
|
||||
pub incoming: SelectAll<UnboundedReceiverStream<(usize, Call)>>,
|
||||
}
|
||||
|
||||
impl Default for Registry {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl Registry {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
inner: HashMap::new(),
|
||||
counter: AtomicUsize::new(0),
|
||||
incoming: SelectAll::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_by_id(&self, id: usize) -> Option<&Client> {
|
||||
self.inner
|
||||
.values()
|
||||
.find(|(client_id, _)| client_id == &id)
|
||||
.map(|(_, client)| client.as_ref())
|
||||
}
|
||||
|
||||
pub fn get(&mut self, language_config: &LanguageConfiguration) -> Result<Arc<Client>> {
|
||||
let config = match &language_config.language_server {
|
||||
Some(config) => config,
|
||||
None => return Err(Error::LspNotDefined),
|
||||
};
|
||||
|
||||
<<<<<<< HEAD
|
||||
match self.inner.entry(language_config.scope.clone()) {
|
||||
Entry::Occupied(entry) => Ok(entry.get().1.clone()),
|
||||
Entry::Vacant(entry) => {
|
||||
// initialize a new client
|
||||
let id = self.counter.fetch_add(1, Ordering::Relaxed);
|
||||
let (client, incoming, initialize_notify) = Client::start(
|
||||
&config.command,
|
||||
&config.args,
|
||||
language_config.config.clone(),
|
||||
&language_config.roots,
|
||||
id,
|
||||
config.timeout,
|
||||
)?;
|
||||
self.incoming.push(UnboundedReceiverStream::new(incoming));
|
||||
let client = Arc::new(client);
|
||||
|
||||
// Initialize the client asynchronously
|
||||
let _client = client.clone();
|
||||
tokio::spawn(async move {
|
||||
use futures_util::TryFutureExt;
|
||||
let value = _client
|
||||
.capabilities
|
||||
.get_or_try_init(|| {
|
||||
_client
|
||||
.initialize()
|
||||
.map_ok(|response| response.capabilities)
|
||||
})
|
||||
.await;
|
||||
|
||||
if let Err(e) = value {
|
||||
log::error!("failed to initialize language server: {}", e);
|
||||
return;
|
||||
}
|
||||
|
||||
// next up, notify<initialized>
|
||||
_client
|
||||
.notify::<lsp::notification::Initialized>(lsp::InitializedParams {})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
initialize_notify.notify_one();
|
||||
});
|
||||
|
||||
entry.insert((id, client.clone()));
|
||||
Ok(client)
|
||||
}
|
||||
||||||| 4b1fe367
|
||||
match self.inner.entry(language_config.scope.clone()) {
|
||||
Entry::Occupied(entry) => Ok(entry.get().1.clone()),
|
||||
Entry::Vacant(entry) => {
|
||||
// initialize a new client
|
||||
let id = self.counter.fetch_add(1, Ordering::Relaxed);
|
||||
let (client, incoming, initialize_notify) = Client::start(
|
||||
&config.command,
|
||||
&config.args,
|
||||
language_config.config.clone(),
|
||||
&language_config.roots,
|
||||
id,
|
||||
)?;
|
||||
self.incoming.push(UnboundedReceiverStream::new(incoming));
|
||||
let client = Arc::new(client);
|
||||
|
||||
// Initialize the client asynchronously
|
||||
let _client = client.clone();
|
||||
tokio::spawn(async move {
|
||||
use futures_util::TryFutureExt;
|
||||
let value = _client
|
||||
.capabilities
|
||||
.get_or_try_init(|| {
|
||||
_client
|
||||
.initialize()
|
||||
.map_ok(|response| response.capabilities)
|
||||
})
|
||||
.await;
|
||||
|
||||
if let Err(e) = value {
|
||||
log::error!("failed to initialize language server: {}", e);
|
||||
return;
|
||||
}
|
||||
|
||||
// next up, notify<initialized>
|
||||
_client
|
||||
.notify::<lsp::notification::Initialized>(lsp::InitializedParams {})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
initialize_notify.notify_one();
|
||||
});
|
||||
|
||||
entry.insert((id, client.clone()));
|
||||
Ok(client)
|
||||
}
|
||||
=======
|
||||
if let Some((_, client)) = self.inner.get(&language_config.scope) {
|
||||
Ok(client.clone())
|
||||
} else {
|
||||
let id = self.counter.fetch_add(1, Ordering::Relaxed);
|
||||
let client = self.initialize_client(language_config, config, id)?; // initialize a new client
|
||||
self.inner
|
||||
.insert(language_config.scope.clone(), (id, client.clone()));
|
||||
Ok(client)
|
||||
>>>>>>> lsp-restart
|
||||
}
|
||||
}
|
||||
|
||||
pub fn restart(&mut self, language_config: &LanguageConfiguration) -> Result<Arc<Client>> {
|
||||
let config = language_config
|
||||
.language_server
|
||||
.as_ref()
|
||||
.ok_or(Error::LspNotDefined)?;
|
||||
let id = self
|
||||
.inner
|
||||
.get(&language_config.scope)
|
||||
.ok_or(Error::LspNotDefined)?
|
||||
.0;
|
||||
let new_client = self.initialize_client(language_config, config, id)?;
|
||||
let (_, client) = self
|
||||
.inner
|
||||
.get_mut(&language_config.scope)
|
||||
.ok_or(Error::LspNotDefined)?;
|
||||
*client = new_client;
|
||||
|
||||
Ok(client.clone())
|
||||
}
|
||||
|
||||
fn initialize_client(
|
||||
&mut self,
|
||||
language_config: &LanguageConfiguration,
|
||||
config: &helix_core::syntax::LanguageServerConfiguration,
|
||||
id: usize,
|
||||
) -> Result<Arc<Client>> {
|
||||
let (client, incoming, initialize_notify) = Client::start(
|
||||
&config.command,
|
||||
&config.args,
|
||||
language_config.config.clone(),
|
||||
&language_config.roots,
|
||||
id,
|
||||
)?;
|
||||
self.incoming.push(UnboundedReceiverStream::new(incoming));
|
||||
let client = Arc::new(client);
|
||||
|
||||
// Initialize the client asynchronously
|
||||
let _client = client.clone();
|
||||
tokio::spawn(async move {
|
||||
use futures_util::TryFutureExt;
|
||||
let value = _client
|
||||
.capabilities
|
||||
.get_or_try_init(|| {
|
||||
_client
|
||||
.initialize()
|
||||
.map_ok(|response| response.capabilities)
|
||||
})
|
||||
.await;
|
||||
|
||||
if let Err(e) = value {
|
||||
log::error!("failed to initialize language server: {}", e);
|
||||
return;
|
||||
}
|
||||
|
||||
// next up, notify<initialized>
|
||||
_client
|
||||
.notify::<lsp::notification::Initialized>(lsp::InitializedParams {})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
initialize_notify.notify_one();
|
||||
});
|
||||
|
||||
Ok(client)
|
||||
}
|
||||
|
||||
pub fn iter_clients(&self) -> impl Iterator<Item = &Arc<Client>> {
|
||||
self.inner.values().map(|(_, client)| client)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum ProgressStatus {
|
||||
Created,
|
||||
Started(lsp::WorkDoneProgress),
|
||||
}
|
||||
|
||||
impl ProgressStatus {
|
||||
pub fn progress(&self) -> Option<&lsp::WorkDoneProgress> {
|
||||
match &self {
|
||||
ProgressStatus::Created => None,
|
||||
ProgressStatus::Started(progress) => Some(progress),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
/// Acts as a container for progress reported by language servers. Each server
|
||||
/// has a unique id assigned at creation through [`Registry`]. This id is then used
|
||||
/// to store the progress in this map.
|
||||
pub struct LspProgressMap(HashMap<usize, HashMap<lsp::ProgressToken, ProgressStatus>>);
|
||||
|
||||
impl LspProgressMap {
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
|
||||
/// Returns a map of all tokens corresponding to the language server with `id`.
|
||||
pub fn progress_map(&self, id: usize) -> Option<&HashMap<lsp::ProgressToken, ProgressStatus>> {
|
||||
self.0.get(&id)
|
||||
}
|
||||
|
||||
pub fn is_progressing(&self, id: usize) -> bool {
|
||||
self.0.get(&id).map(|it| !it.is_empty()).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Returns last progress status for a given server with `id` and `token`.
|
||||
pub fn progress(&self, id: usize, token: &lsp::ProgressToken) -> Option<&ProgressStatus> {
|
||||
self.0.get(&id).and_then(|values| values.get(token))
|
||||
}
|
||||
|
||||
/// Checks if progress `token` for server with `id` is created.
|
||||
pub fn is_created(&mut self, id: usize, token: &lsp::ProgressToken) -> bool {
|
||||
self.0
|
||||
.get(&id)
|
||||
.map(|values| values.get(token).is_some())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
pub fn create(&mut self, id: usize, token: lsp::ProgressToken) {
|
||||
self.0
|
||||
.entry(id)
|
||||
.or_default()
|
||||
.insert(token, ProgressStatus::Created);
|
||||
}
|
||||
|
||||
/// Ends the progress by removing the `token` from server with `id`, if removed returns the value.
|
||||
pub fn end_progress(
|
||||
&mut self,
|
||||
id: usize,
|
||||
token: &lsp::ProgressToken,
|
||||
) -> Option<ProgressStatus> {
|
||||
self.0.get_mut(&id).and_then(|vals| vals.remove(token))
|
||||
}
|
||||
|
||||
/// Updates the progress of `token` for server with `id` to `status`, returns the value replaced or `None`.
|
||||
pub fn update(
|
||||
&mut self,
|
||||
id: usize,
|
||||
token: lsp::ProgressToken,
|
||||
status: lsp::WorkDoneProgress,
|
||||
) -> Option<ProgressStatus> {
|
||||
self.0
|
||||
.entry(id)
|
||||
.or_default()
|
||||
.insert(token, ProgressStatus::Started(status))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{lsp, util::*, OffsetEncoding};
|
||||
use helix_core::Rope;
|
||||
|
||||
#[test]
|
||||
fn converts_lsp_pos_to_pos() {
|
||||
macro_rules! test_case {
|
||||
($doc:expr, ($x:expr, $y:expr) => $want:expr) => {
|
||||
let doc = Rope::from($doc);
|
||||
let pos = lsp::Position::new($x, $y);
|
||||
assert_eq!($want, lsp_pos_to_pos(&doc, pos, OffsetEncoding::Utf16));
|
||||
assert_eq!($want, lsp_pos_to_pos(&doc, pos, OffsetEncoding::Utf8))
|
||||
};
|
||||
}
|
||||
|
||||
test_case!("", (0, 0) => Some(0));
|
||||
test_case!("", (0, 1) => None);
|
||||
test_case!("", (1, 0) => None);
|
||||
test_case!("\n\n", (0, 0) => Some(0));
|
||||
test_case!("\n\n", (1, 0) => Some(1));
|
||||
test_case!("\n\n", (1, 1) => Some(2));
|
||||
test_case!("\n\n", (2, 0) => Some(2));
|
||||
test_case!("\n\n", (3, 0) => None);
|
||||
test_case!("test\n\n\n\ncase", (4, 3) => Some(11));
|
||||
test_case!("test\n\n\n\ncase", (4, 4) => Some(12));
|
||||
test_case!("test\n\n\n\ncase", (4, 5) => None);
|
||||
test_case!("", (u32::MAX, u32::MAX) => None);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue