aboutsummaryrefslogtreecommitdiff
path: root/helix-term/src
diff options
context:
space:
mode:
Diffstat (limited to 'helix-term/src')
-rw-r--r--helix-term/src/commands.rs778
-rw-r--r--helix-term/src/commands/lsp.rs776
2 files changed, 785 insertions, 769 deletions
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index 73addcee..7e8b1d53 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -1,6 +1,8 @@
pub(crate) mod dap;
+pub(crate) mod lsp;
pub use dap::*;
+pub use lsp::*;
use helix_core::{
comment, coords_at_pos, find_first_non_whitespace_char, find_root, graphemes,
@@ -33,11 +35,6 @@ use helix_view::{
use anyhow::{anyhow, bail, ensure, Context as _};
use fuzzy_matcher::FuzzyMatcher;
-use helix_lsp::{
- block_on, lsp,
- util::{lsp_pos_to_pos, lsp_range_to_range, pos_to_lsp_pos, range_to_lsp_range},
- OffsetEncoding,
-};
use insert::*;
use movement::Movement;
@@ -2754,7 +2751,7 @@ pub mod cmd {
// TODO: support no frame_id
let frame_id = debugger.stack_frames[&thread_id][frame].id;
- let response = block_on(debugger.eval(args.join(" "), Some(frame_id)))?;
+ let response = helix_lsp::block_on(debugger.eval(args.join(" "), Some(frame_id)))?;
cx.editor.set_status(response.result);
}
Ok(())
@@ -3474,217 +3471,6 @@ fn buffer_picker(cx: &mut Context) {
cx.push_layer(Box::new(overlayed(picker)));
}
-fn sym_picker(
- symbols: Vec<lsp::SymbolInformation>,
- current_path: Option<lsp::Url>,
- offset_encoding: OffsetEncoding,
-) -> FilePicker<lsp::SymbolInformation> {
- // TODO: drop current_path comparison and instead use workspace: bool flag?
- let current_path2 = current_path.clone();
- let mut picker = FilePicker::new(
- symbols,
- move |symbol| {
- if current_path.as_ref() == Some(&symbol.location.uri) {
- symbol.name.as_str().into()
- } else {
- let path = symbol.location.uri.to_file_path().unwrap();
- let relative_path = helix_core::path::get_relative_path(path.as_path())
- .to_string_lossy()
- .into_owned();
- format!("{} ({})", &symbol.name, relative_path).into()
- }
- },
- move |cx, symbol, action| {
- if current_path2.as_ref() == Some(&symbol.location.uri) {
- push_jump(cx.editor);
- } else {
- let path = symbol.location.uri.to_file_path().unwrap();
- cx.editor.open(path, action).expect("editor.open failed");
- }
-
- let (view, doc) = current!(cx.editor);
-
- if let Some(range) =
- lsp_range_to_range(doc.text(), symbol.location.range, offset_encoding)
- {
- // we flip the range so that the cursor sits on the start of the symbol
- // (for example start of the function).
- doc.set_selection(view.id, Selection::single(range.head, range.anchor));
- align_view(doc, view, Align::Center);
- }
- },
- move |_editor, symbol| {
- let path = symbol.location.uri.to_file_path().unwrap();
- let line = Some((
- symbol.location.range.start.line as usize,
- symbol.location.range.end.line as usize,
- ));
- Some((path, line))
- },
- );
- picker.truncate_start = false;
- picker
-}
-
-fn symbol_picker(cx: &mut Context) {
- fn nested_to_flat(
- list: &mut Vec<lsp::SymbolInformation>,
- file: &lsp::TextDocumentIdentifier,
- symbol: lsp::DocumentSymbol,
- ) {
- #[allow(deprecated)]
- list.push(lsp::SymbolInformation {
- name: symbol.name,
- kind: symbol.kind,
- tags: symbol.tags,
- deprecated: symbol.deprecated,
- location: lsp::Location::new(file.uri.clone(), symbol.selection_range),
- container_name: None,
- });
- for child in symbol.children.into_iter().flatten() {
- nested_to_flat(list, file, child);
- }
- }
- let doc = doc!(cx.editor);
-
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
- let current_url = doc.url();
- let offset_encoding = language_server.offset_encoding();
-
- let future = language_server.document_symbols(doc.identifier());
-
- cx.callback(
- future,
- move |editor: &mut Editor,
- compositor: &mut Compositor,
- response: Option<lsp::DocumentSymbolResponse>| {
- if let Some(symbols) = response {
- // lsp has two ways to represent symbols (flat/nested)
- // convert the nested variant to flat, so that we have a homogeneous list
- let symbols = match symbols {
- lsp::DocumentSymbolResponse::Flat(symbols) => symbols,
- lsp::DocumentSymbolResponse::Nested(symbols) => {
- let doc = doc!(editor);
- let mut flat_symbols = Vec::new();
- for symbol in symbols {
- nested_to_flat(&mut flat_symbols, &doc.identifier(), symbol)
- }
- flat_symbols
- }
- };
-
- let picker = sym_picker(symbols, current_url, offset_encoding);
- compositor.push(Box::new(overlayed(picker)))
- }
- },
- )
-}
-
-fn workspace_symbol_picker(cx: &mut Context) {
- let doc = doc!(cx.editor);
- let current_url = doc.url();
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
- let offset_encoding = language_server.offset_encoding();
- let future = language_server.workspace_symbols("".to_string());
-
- cx.callback(
- future,
- move |_editor: &mut Editor,
- compositor: &mut Compositor,
- response: Option<Vec<lsp::SymbolInformation>>| {
- if let Some(symbols) = response {
- let picker = sym_picker(symbols, current_url, offset_encoding);
- compositor.push(Box::new(overlayed(picker)))
- }
- },
- )
-}
-
-impl ui::menu::Item for lsp::CodeActionOrCommand {
- fn label(&self) -> &str {
- match self {
- lsp::CodeActionOrCommand::CodeAction(action) => action.title.as_str(),
- lsp::CodeActionOrCommand::Command(command) => command.title.as_str(),
- }
- }
-}
-
-pub fn code_action(cx: &mut Context) {
- let (view, doc) = current!(cx.editor);
-
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- let range = range_to_lsp_range(
- doc.text(),
- doc.selection(view.id).primary(),
- language_server.offset_encoding(),
- );
-
- let future = language_server.code_actions(doc.identifier(), range);
- let offset_encoding = language_server.offset_encoding();
-
- cx.callback(
- future,
- move |editor: &mut Editor,
- compositor: &mut Compositor,
- response: Option<lsp::CodeActionResponse>| {
- let actions = match response {
- Some(a) => a,
- None => return,
- };
- if actions.is_empty() {
- editor.set_status("No code actions available");
- return;
- }
-
- let mut picker = ui::Menu::new(actions, move |editor, code_action, event| {
- if event != PromptEvent::Validate {
- return;
- }
-
- // always present here
- let code_action = code_action.unwrap();
-
- match code_action {
- lsp::CodeActionOrCommand::Command(command) => {
- log::debug!("code action command: {:?}", command);
- execute_lsp_command(editor, command.clone());
- }
- lsp::CodeActionOrCommand::CodeAction(code_action) => {
- log::debug!("code action: {:?}", code_action);
- if let Some(ref workspace_edit) = code_action.edit {
- log::debug!("edit: {:?}", workspace_edit);
- apply_workspace_edit(editor, offset_encoding, workspace_edit);
- }
-
- // if code action provides both edit and command first the edit
- // should be applied and then the command
- if let Some(command) = &code_action.command {
- execute_lsp_command(editor, command.clone());
- }
- }
- }
- });
- picker.move_down(); // pre-select the first item
-
- let popup = Popup::new("code-action", picker).margin(helix_view::graphics::Margin {
- vertical: 1,
- horizontal: 1,
- });
- compositor.replace_or_push("code-action", Box::new(popup));
- },
- )
-}
-
pub fn command_palette(cx: &mut Context) {
cx.callback = Some(Box::new(
move |compositor: &mut Compositor, cx: &mut compositor::Context| {
@@ -3748,180 +3534,6 @@ pub fn command_palette(cx: &mut Context) {
));
}
-pub fn execute_lsp_command(editor: &mut Editor, cmd: lsp::Command) {
- let doc = doc!(editor);
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- // the command is executed on the server and communicated back
- // to the client asynchronously using workspace edits
- let command_future = language_server.command(cmd);
- tokio::spawn(async move {
- let res = command_future.await;
-
- if let Err(e) = res {
- log::error!("execute LSP command: {}", e);
- }
- });
-}
-
-pub fn apply_document_resource_op(op: &lsp::ResourceOp) -> std::io::Result<()> {
- use lsp::ResourceOp;
- use std::fs;
- match op {
- ResourceOp::Create(op) => {
- let path = op.uri.to_file_path().unwrap();
- let ignore_if_exists = op.options.as_ref().map_or(false, |options| {
- !options.overwrite.unwrap_or(false) && options.ignore_if_exists.unwrap_or(false)
- });
- if ignore_if_exists && path.exists() {
- Ok(())
- } else {
- fs::write(&path, [])
- }
- }
- ResourceOp::Delete(op) => {
- let path = op.uri.to_file_path().unwrap();
- if path.is_dir() {
- let recursive = op
- .options
- .as_ref()
- .and_then(|options| options.recursive)
- .unwrap_or(false);
-
- if recursive {
- fs::remove_dir_all(&path)
- } else {
- fs::remove_dir(&path)
- }
- } else if path.is_file() {
- fs::remove_file(&path)
- } else {
- Ok(())
- }
- }
- ResourceOp::Rename(op) => {
- let from = op.old_uri.to_file_path().unwrap();
- let to = op.new_uri.to_file_path().unwrap();
- let ignore_if_exists = op.options.as_ref().map_or(false, |options| {
- !options.overwrite.unwrap_or(false) && options.ignore_if_exists.unwrap_or(false)
- });
- if ignore_if_exists && to.exists() {
- Ok(())
- } else {
- fs::rename(&from, &to)
- }
- }
- }
-}
-
-pub fn apply_workspace_edit(
- editor: &mut Editor,
- offset_encoding: OffsetEncoding,
- workspace_edit: &lsp::WorkspaceEdit,
-) {
- let mut apply_edits = |uri: &helix_lsp::Url, text_edits: Vec<lsp::TextEdit>| {
- let path = uri
- .to_file_path()
- .expect("unable to convert URI to filepath");
-
- let current_view_id = view!(editor).id;
- let doc_id = editor.open(path, Action::Load).unwrap();
- let doc = editor
- .document_mut(doc_id)
- .expect("Document for document_changes not found");
-
- // Need to determine a view for apply/append_changes_to_history
- let selections = doc.selections();
- let view_id = if selections.contains_key(&current_view_id) {
- // use current if possible
- current_view_id
- } else {
- // Hack: we take the first available view_id
- selections
- .keys()
- .next()
- .copied()
- .expect("No view_id available")
- };
-
- let transaction = helix_lsp::util::generate_transaction_from_edits(
- doc.text(),
- text_edits,
- offset_encoding,
- );
- doc.apply(&transaction, view_id);
- doc.append_changes_to_history(view_id);
- };
-
- if let Some(ref changes) = workspace_edit.changes {
- log::debug!("workspace changes: {:?}", changes);
- for (uri, text_edits) in changes {
- let text_edits = text_edits.to_vec();
- apply_edits(uri, text_edits);
- }
- return;
- // Not sure if it works properly, it'll be safer to just panic here to avoid breaking some parts of code on which code actions will be used
- // TODO: find some example that uses workspace changes, and test it
- // for (url, edits) in changes.iter() {
- // let file_path = url.origin().ascii_serialization();
- // let file_path = std::path::PathBuf::from(file_path);
- // let file = std::fs::File::open(file_path).unwrap();
- // let mut text = Rope::from_reader(file).unwrap();
- // let transaction = edits_to_changes(&text, edits);
- // transaction.apply(&mut text);
- // }
- }
-
- if let Some(ref document_changes) = workspace_edit.document_changes {
- match document_changes {
- lsp::DocumentChanges::Edits(document_edits) => {
- for document_edit in document_edits {
- let edits = document_edit
- .edits
- .iter()
- .map(|edit| match edit {
- lsp::OneOf::Left(text_edit) => text_edit,
- lsp::OneOf::Right(annotated_text_edit) => {
- &annotated_text_edit.text_edit
- }
- })
- .cloned()
- .collect();
- apply_edits(&document_edit.text_document.uri, edits);
- }
- }
- lsp::DocumentChanges::Operations(operations) => {
- log::debug!("document changes - operations: {:?}", operations);
- for operateion in operations {
- match operateion {
- lsp::DocumentChangeOperation::Op(op) => {
- apply_document_resource_op(op).unwrap();
- }
-
- lsp::DocumentChangeOperation::Edit(document_edit) => {
- let edits = document_edit
- .edits
- .iter()
- .map(|edit| match edit {
- lsp::OneOf::Left(text_edit) => text_edit,
- lsp::OneOf::Right(annotated_text_edit) => {
- &annotated_text_edit.text_edit
- }
- })
- .cloned()
- .collect();
- apply_edits(&document_edit.text_document.uri, edits);
- }
- }
- }
- }
- }
- }
-}
-
fn last_picker(cx: &mut Context) {
// TODO: last picker does not seem to work well with buffer_picker
cx.callback = Some(Box::new(|compositor: &mut Compositor, _| {
@@ -4250,247 +3862,6 @@ fn exit_select_mode(cx: &mut Context) {
}
}
-fn goto_impl(
- editor: &mut Editor,
- compositor: &mut Compositor,
- locations: Vec<lsp::Location>,
- offset_encoding: OffsetEncoding,
-) {
- push_jump(editor);
-
- // TODO: share with symbol picker(symbol.location)
- fn jump_to(
- editor: &mut Editor,
- location: &lsp::Location,
- offset_encoding: OffsetEncoding,
- action: Action,
- ) {
- let path = location
- .uri
- .to_file_path()
- .expect("unable to convert URI to filepath");
- let _id = editor.open(path, action).expect("editor.open failed");
- let (view, doc) = current!(editor);
- let definition_pos = location.range.start;
- // TODO: convert inside server
- let new_pos =
- if let Some(new_pos) = lsp_pos_to_pos(doc.text(), definition_pos, offset_encoding) {
- new_pos
- } else {
- return;
- };
- doc.set_selection(view.id, Selection::point(new_pos));
- align_view(doc, view, Align::Center);
- }
-
- let cwdir = std::env::current_dir().expect("couldn't determine current directory");
-
- match locations.as_slice() {
- [location] => {
- jump_to(editor, location, offset_encoding, Action::Replace);
- }
- [] => {
- editor.set_error("No definition found.");
- }
- _locations => {
- let picker = FilePicker::new(
- locations,
- move |location| {
- let file: Cow<'_, str> = (location.uri.scheme() == "file")
- .then(|| {
- location
- .uri
- .to_file_path()
- .map(|path| {
- // strip root prefix
- path.strip_prefix(&cwdir)
- .map(|path| path.to_path_buf())
- .unwrap_or(path)
- })
- .map(|path| Cow::from(path.to_string_lossy().into_owned()))
- .ok()
- })
- .flatten()
- .unwrap_or_else(|| location.uri.as_str().into());
- let line = location.range.start.line;
- format!("{}:{}", file, line).into()
- },
- move |cx, location, action| jump_to(cx.editor, location, offset_encoding, action),
- |_editor, location| {
- // TODO: share code for symbol.location and location
- let path = location.uri.to_file_path().unwrap();
- let line = Some((
- location.range.start.line as usize,
- location.range.end.line as usize,
- ));
- Some((path, line))
- },
- );
- compositor.push(Box::new(overlayed(picker)));
- }
- }
-}
-
-fn goto_definition(cx: &mut Context) {
- let (view, doc) = current!(cx.editor);
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- let offset_encoding = language_server.offset_encoding();
-
- let pos = pos_to_lsp_pos(
- doc.text(),
- doc.selection(view.id)
- .primary()
- .cursor(doc.text().slice(..)),
- offset_encoding,
- );
-
- let future = language_server.goto_definition(doc.identifier(), pos, None);
-
- cx.callback(
- future,
- move |editor: &mut Editor,
- compositor: &mut Compositor,
- response: Option<lsp::GotoDefinitionResponse>| {
- let items = match response {
- Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],
- Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,
- Some(lsp::GotoDefinitionResponse::Link(locations)) => locations
- .into_iter()
- .map(|location_link| lsp::Location {
- uri: location_link.target_uri,
- range: location_link.target_range,
- })
- .collect(),
- None => Vec::new(),
- };
-
- goto_impl(editor, compositor, items, offset_encoding);
- },
- );
-}
-
-fn goto_type_definition(cx: &mut Context) {
- let (view, doc) = current!(cx.editor);
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- let offset_encoding = language_server.offset_encoding();
-
- let pos = pos_to_lsp_pos(
- doc.text(),
- doc.selection(view.id)
- .primary()
- .cursor(doc.text().slice(..)),
- offset_encoding,
- );
-
- let future = language_server.goto_type_definition(doc.identifier(), pos, None);
-
- cx.callback(
- future,
- move |editor: &mut Editor,
- compositor: &mut Compositor,
- response: Option<lsp::GotoDefinitionResponse>| {
- let items = match response {
- Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],
- Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,
- Some(lsp::GotoDefinitionResponse::Link(locations)) => locations
- .into_iter()
- .map(|location_link| lsp::Location {
- uri: location_link.target_uri,
- range: location_link.target_range,
- })
- .collect(),
- None => Vec::new(),
- };
-
- goto_impl(editor, compositor, items, offset_encoding);
- },
- );
-}
-
-fn goto_implementation(cx: &mut Context) {
- let (view, doc) = current!(cx.editor);
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- let offset_encoding = language_server.offset_encoding();
-
- let pos = pos_to_lsp_pos(
- doc.text(),
- doc.selection(view.id)
- .primary()
- .cursor(doc.text().slice(..)),
- offset_encoding,
- );
-
- let future = language_server.goto_implementation(doc.identifier(), pos, None);
-
- cx.callback(
- future,
- move |editor: &mut Editor,
- compositor: &mut Compositor,
- response: Option<lsp::GotoDefinitionResponse>| {
- let items = match response {
- Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],
- Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,
- Some(lsp::GotoDefinitionResponse::Link(locations)) => locations
- .into_iter()
- .map(|location_link| lsp::Location {
- uri: location_link.target_uri,
- range: location_link.target_range,
- })
- .collect(),
- None => Vec::new(),
- };
-
- goto_impl(editor, compositor, items, offset_encoding);
- },
- );
-}
-
-fn goto_reference(cx: &mut Context) {
- let (view, doc) = current!(cx.editor);
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- let offset_encoding = language_server.offset_encoding();
-
- let pos = pos_to_lsp_pos(
- doc.text(),
- doc.selection(view.id)
- .primary()
- .cursor(doc.text().slice(..)),
- offset_encoding,
- );
-
- let future = language_server.goto_reference(doc.identifier(), pos, None);
-
- cx.callback(
- future,
- move |editor: &mut Editor,
- compositor: &mut Compositor,
- items: Option<Vec<lsp::Location>>| {
- goto_impl(
- editor,
- compositor,
- items.unwrap_or_default(),
- offset_encoding,
- );
- },
- );
-}
-
fn goto_pos(editor: &mut Editor, pos: usize) {
push_jump(editor);
@@ -4565,46 +3936,6 @@ fn goto_prev_diag(cx: &mut Context) {
goto_pos(editor, pos);
}
-fn signature_help(cx: &mut Context) {
- let (view, doc) = current!(cx.editor);
-
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- let pos = pos_to_lsp_pos(
- doc.text(),
- doc.selection(view.id)
- .primary()
- .cursor(doc.text().slice(..)),
- language_server.offset_encoding(),
- );
-
- let future = language_server.text_document_signature_help(doc.identifier(), pos, None);
-
- cx.callback(
- future,
- move |_editor: &mut Editor,
- _compositor: &mut Compositor,
- response: Option<lsp::SignatureHelp>| {
- if let Some(signature_help) = response {
- log::info!("{:?}", signature_help);
- // signatures
- // active_signature
- // active_parameter
- // render as:
-
- // signature
- // ----------
- // doc
-
- // with active param highlighted
- }
- },
- );
-}
-
pub mod insert {
use super::*;
pub type Hook = fn(&Rope, &Selection, char) -> Option<Transaction>;
@@ -4630,6 +3961,7 @@ pub mod insert {
}
fn language_server_completion(cx: &mut Context, ch: char) {
+ use helix_lsp::lsp;
// if ch matches completion char, trigger completion
let doc = doc_mut!(cx.editor);
let language_server = match doc.language_server() {
@@ -4653,6 +3985,7 @@ pub mod insert {
}
fn signature_help(cx: &mut Context, ch: char) {
+ use helix_lsp::lsp;
// if ch matches signature_help char, trigger
let doc = doc_mut!(cx.editor);
let language_server = match doc.language_server() {
@@ -5360,6 +4693,8 @@ fn unindent(cx: &mut Context) {
}
fn format_selections(cx: &mut Context) {
+ use helix_lsp::{lsp, util::range_to_lsp_range};
+
let (view, doc) = current!(cx.editor);
// via lsp if available
@@ -5504,6 +4839,8 @@ fn remove_primary_selection(cx: &mut Context) {
}
pub fn completion(cx: &mut Context) {
+ use helix_lsp::{lsp, util::pos_to_lsp_pos};
+
// trigger on trigger char, or if user calls it
// (or on word char typing??)
// after it's triggered, if response marked is_incomplete, update on every subsequent keypress
@@ -5618,66 +4955,6 @@ pub fn completion(cx: &mut Context) {
);
}
-fn hover(cx: &mut Context) {
- let (view, doc) = current!(cx.editor);
-
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- // TODO: factor out a doc.position_identifier() that returns lsp::TextDocumentPositionIdentifier
-
- let pos = pos_to_lsp_pos(
- doc.text(),
- doc.selection(view.id)
- .primary()
- .cursor(doc.text().slice(..)),
- language_server.offset_encoding(),
- );
-
- let future = language_server.text_document_hover(doc.identifier(), pos, None);
-
- cx.callback(
- future,
- move |editor: &mut Editor, compositor: &mut Compositor, response: Option<lsp::Hover>| {
- if let Some(hover) = response {
- // hover.contents / .range <- used for visualizing
-
- fn marked_string_to_markdown(contents: lsp::MarkedString) -> String {
- match contents {
- lsp::MarkedString::String(contents) => contents,
- lsp::MarkedString::LanguageString(string) => {
- if string.language == "markdown" {
- string.value
- } else {
- format!("```{}\n{}\n```", string.language, string.value)
- }
- }
- }
- }
-
- let contents = match hover.contents {
- lsp::HoverContents::Scalar(contents) => marked_string_to_markdown(contents),
- lsp::HoverContents::Array(contents) => contents
- .into_iter()
- .map(marked_string_to_markdown)
- .collect::<Vec<_>>()
- .join("\n\n"),
- lsp::HoverContents::Markup(contents) => contents.value,
- };
-
- // skip if contents empty
-
- let contents =
- ui::Markdown::new(contents, editor.syn_loader.clone()).style_group("hover");
- let popup = Popup::new("hover", contents);
- compositor.replace_or_push("hover", Box::new(popup));
- }
- },
- );
-}
-
// comments
fn toggle_comments(cx: &mut Context) {
let (view, doc) = current!(cx.editor);
@@ -6406,43 +5683,6 @@ fn add_newline_impl(cx: &mut Context, open: Open) {
doc.apply(&transaction, view.id);
}
-fn rename_symbol(cx: &mut Context) {
- let prompt = Prompt::new(
- "rename-to:".into(),
- None,
- ui::completers::none,
- move |cx: &mut compositor::Context, input: &str, event: PromptEvent| {
- if event != PromptEvent::Validate {
- return;
- }
-
- log::debug!("renaming to: {:?}", input);
-
- let (view, doc) = current!(cx.editor);
- let language_server = match doc.language_server() {
- Some(language_server) => language_server,
- None => return,
- };
-
- let offset_encoding = language_server.offset_encoding();
-
- let pos = pos_to_lsp_pos(
- doc.text(),
- doc.selection(view.id)
- .primary()
- .cursor(doc.text().slice(..)),
- offset_encoding,
- );
-
- let task = language_server.rename_symbol(doc.identifier(), pos, input.to_string());
- let edits = block_on(task).unwrap_or_default();
- log::debug!("Edits from LSP: {:?}", edits);
- apply_workspace_edit(cx.editor, offset_encoding, &edits);
- },
- );
- cx.push_layer(Box::new(prompt));
-}
-
/// Increment object under cursor by count.
fn increment(cx: &mut Context) {
increment_impl(cx, cx.count() as i64);
diff --git a/helix-term/src/commands/lsp.rs b/helix-term/src/commands/lsp.rs
new file mode 100644
index 00000000..084c7c6a
--- /dev/null
+++ b/helix-term/src/commands/lsp.rs
@@ -0,0 +1,776 @@
+use helix_lsp::{
+ block_on, lsp,
+ util::{lsp_pos_to_pos, lsp_range_to_range, pos_to_lsp_pos, range_to_lsp_range},
+ OffsetEncoding,
+};
+
+use super::{align_view, push_jump, Align, Context, Editor};
+
+use helix_core::Selection;
+use helix_view::editor::Action;
+
+use crate::{
+ compositor::{self, Compositor},
+ ui::{self, overlay::overlayed, FilePicker, Popup, Prompt, PromptEvent},
+};
+
+use std::borrow::Cow;
+
+fn sym_picker(
+ symbols: Vec<lsp::SymbolInformation>,
+ current_path: Option<lsp::Url>,
+ offset_encoding: OffsetEncoding,
+) -> FilePicker<lsp::SymbolInformation> {
+ // TODO: drop current_path comparison and instead use workspace: bool flag?
+ let current_path2 = current_path.clone();
+ let mut picker = FilePicker::new(
+ symbols,
+ move |symbol| {
+ if current_path.as_ref() == Some(&symbol.location.uri) {
+ symbol.name.as_str().into()
+ } else {
+ let path = symbol.location.uri.to_file_path().unwrap();
+ let relative_path = helix_core::path::get_relative_path(path.as_path())
+ .to_string_lossy()
+ .into_owned();
+ format!("{} ({})", &symbol.name, relative_path).into()
+ }
+ },
+ move |cx, symbol, action| {
+ if current_path2.as_ref() == Some(&symbol.location.uri) {
+ push_jump(cx.editor);
+ } else {
+ let path = symbol.location.uri.to_file_path().unwrap();
+ cx.editor.open(path, action).expect("editor.open failed");
+ }
+
+ let (view, doc) = current!(cx.editor);
+
+ if let Some(range) =
+ lsp_range_to_range(doc.text(), symbol.location.range, offset_encoding)
+ {
+ // we flip the range so that the cursor sits on the start of the symbol
+ // (for example start of the function).
+ doc.set_selection(view.id, Selection::single(range.head, range.anchor));
+ align_view(doc, view, Align::Center);
+ }
+ },
+ move |_editor, symbol| {
+ let path = symbol.location.uri.to_file_path().unwrap();
+ let line = Some((
+ symbol.location.range.start.line as usize,
+ symbol.location.range.end.line as usize,
+ ));
+ Some((path, line))
+ },
+ );
+ picker.truncate_start = false;
+ picker
+}
+
+pub fn symbol_picker(cx: &mut Context) {
+ fn nested_to_flat(
+ list: &mut Vec<lsp::SymbolInformation>,
+ file: &lsp::TextDocumentIdentifier,
+ symbol: lsp::DocumentSymbol,
+ ) {
+ #[allow(deprecated)]
+ list.push(lsp::SymbolInformation {
+ name: symbol.name,
+ kind: symbol.kind,
+ tags: symbol.tags,
+ deprecated: symbol.deprecated,
+ location: lsp::Location::new(file.uri.clone(), symbol.selection_range),
+ container_name: None,
+ });
+ for child in symbol.children.into_iter().flatten() {
+ nested_to_flat(list, file, child);
+ }
+ }
+ let doc = doc!(cx.editor);
+
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+ let current_url = doc.url();
+ let offset_encoding = language_server.offset_encoding();
+
+ let future = language_server.document_symbols(doc.identifier());
+
+ cx.callback(
+ future,
+ move |editor: &mut Editor,
+ compositor: &mut Compositor,
+ response: Option<lsp::DocumentSymbolResponse>| {
+ if let Some(symbols) = response {
+ // lsp has two ways to represent symbols (flat/nested)
+ // convert the nested variant to flat, so that we have a homogeneous list
+ let symbols = match symbols {
+ lsp::DocumentSymbolResponse::Flat(symbols) => symbols,
+ lsp::DocumentSymbolResponse::Nested(symbols) => {
+ let doc = doc!(editor);
+ let mut flat_symbols = Vec::new();
+ for symbol in symbols {
+ nested_to_flat(&mut flat_symbols, &doc.identifier(), symbol)
+ }
+ flat_symbols
+ }
+ };
+
+ let picker = sym_picker(symbols, current_url, offset_encoding);
+ compositor.push(Box::new(overlayed(picker)))
+ }
+ },
+ )
+}
+
+pub fn workspace_symbol_picker(cx: &mut Context) {
+ let doc = doc!(cx.editor);
+ let current_url = doc.url();
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+ let offset_encoding = language_server.offset_encoding();
+ let future = language_server.workspace_symbols("".to_string());
+
+ cx.callback(
+ future,
+ move |_editor: &mut Editor,
+ compositor: &mut Compositor,
+ response: Option<Vec<lsp::SymbolInformation>>| {
+ if let Some(symbols) = response {
+ let picker = sym_picker(symbols, current_url, offset_encoding);
+ compositor.push(Box::new(overlayed(picker)))
+ }
+ },
+ )
+}
+
+impl ui::menu::Item for lsp::CodeActionOrCommand {
+ fn label(&self) -> &str {
+ match self {
+ lsp::CodeActionOrCommand::CodeAction(action) => action.title.as_str(),
+ lsp::CodeActionOrCommand::Command(command) => command.title.as_str(),
+ }
+ }
+}
+
+pub fn code_action(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ let range = range_to_lsp_range(
+ doc.text(),
+ doc.selection(view.id).primary(),
+ language_server.offset_encoding(),
+ );
+
+ let future = language_server.code_actions(doc.identifier(), range);
+ let offset_encoding = language_server.offset_encoding();
+
+ cx.callback(
+ future,
+ move |editor: &mut Editor,
+ compositor: &mut Compositor,
+ response: Option<lsp::CodeActionResponse>| {
+ let actions = match response {
+ Some(a) => a,
+ None => return,
+ };
+ if actions.is_empty() {
+ editor.set_status("No code actions available");
+ return;
+ }
+
+ let mut picker = ui::Menu::new(actions, move |editor, code_action, event| {
+ if event != PromptEvent::Validate {
+ return;
+ }
+
+ // always present here
+ let code_action = code_action.unwrap();
+
+ match code_action {
+ lsp::CodeActionOrCommand::Command(command) => {
+ log::debug!("code action command: {:?}", command);
+ execute_lsp_command(editor, command.clone());
+ }
+ lsp::CodeActionOrCommand::CodeAction(code_action) => {
+ log::debug!("code action: {:?}", code_action);
+ if let Some(ref workspace_edit) = code_action.edit {
+ log::debug!("edit: {:?}", workspace_edit);
+ apply_workspace_edit(editor, offset_encoding, workspace_edit);
+ }
+
+ // if code action provides both edit and command first the edit
+ // should be applied and then the command
+ if let Some(command) = &code_action.command {
+ execute_lsp_command(editor, command.clone());
+ }
+ }
+ }
+ });
+ picker.move_down(); // pre-select the first item
+
+ let popup = Popup::new("code-action", picker).margin(helix_view::graphics::Margin {
+ vertical: 1,
+ horizontal: 1,
+ });
+ compositor.replace_or_push("code-action", Box::new(popup));
+ },
+ )
+}
+pub fn execute_lsp_command(editor: &mut Editor, cmd: lsp::Command) {
+ let doc = doc!(editor);
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ // the command is executed on the server and communicated back
+ // to the client asynchronously using workspace edits
+ let command_future = language_server.command(cmd);
+ tokio::spawn(async move {
+ let res = command_future.await;
+
+ if let Err(e) = res {
+ log::error!("execute LSP command: {}", e);
+ }
+ });
+}
+
+pub fn apply_document_resource_op(op: &lsp::ResourceOp) -> std::io::Result<()> {
+ use lsp::ResourceOp;
+ use std::fs;
+ match op {
+ ResourceOp::Create(op) => {
+ let path = op.uri.to_file_path().unwrap();
+ let ignore_if_exists = op.options.as_ref().map_or(false, |options| {
+ !options.overwrite.unwrap_or(false) && options.ignore_if_exists.unwrap_or(false)
+ });
+ if ignore_if_exists && path.exists() {
+ Ok(())
+ } else {
+ fs::write(&path, [])
+ }
+ }
+ ResourceOp::Delete(op) => {
+ let path = op.uri.to_file_path().unwrap();
+ if path.is_dir() {
+ let recursive = op
+ .options
+ .as_ref()
+ .and_then(|options| options.recursive)
+ .unwrap_or(false);
+
+ if recursive {
+ fs::remove_dir_all(&path)
+ } else {
+ fs::remove_dir(&path)
+ }
+ } else if path.is_file() {
+ fs::remove_file(&path)
+ } else {
+ Ok(())
+ }
+ }
+ ResourceOp::Rename(op) => {
+ let from = op.old_uri.to_file_path().unwrap();
+ let to = op.new_uri.to_file_path().unwrap();
+ let ignore_if_exists = op.options.as_ref().map_or(false, |options| {
+ !options.overwrite.unwrap_or(false) && options.ignore_if_exists.unwrap_or(false)
+ });
+ if ignore_if_exists && to.exists() {
+ Ok(())
+ } else {
+ fs::rename(&from, &to)
+ }
+ }
+ }
+}
+
+pub fn apply_workspace_edit(
+ editor: &mut Editor,
+ offset_encoding: OffsetEncoding,
+ workspace_edit: &lsp::WorkspaceEdit,
+) {
+ let mut apply_edits = |uri: &helix_lsp::Url, text_edits: Vec<lsp::TextEdit>| {
+ let path = uri
+ .to_file_path()
+ .expect("unable to convert URI to filepath");
+
+ let current_view_id = view!(editor).id;
+ let doc_id = editor.open(path, Action::Load).unwrap();
+ let doc = editor
+ .document_mut(doc_id)
+ .expect("Document for document_changes not found");
+
+ // Need to determine a view for apply/append_changes_to_history
+ let selections = doc.selections();
+ let view_id = if selections.contains_key(&current_view_id) {
+ // use current if possible
+ current_view_id
+ } else {
+ // Hack: we take the first available view_id
+ selections
+ .keys()
+ .next()
+ .copied()
+ .expect("No view_id available")
+ };
+
+ let transaction = helix_lsp::util::generate_transaction_from_edits(
+ doc.text(),
+ text_edits,
+ offset_encoding,
+ );
+ doc.apply(&transaction, view_id);
+ doc.append_changes_to_history(view_id);
+ };
+
+ if let Some(ref changes) = workspace_edit.changes {
+ log::debug!("workspace changes: {:?}", changes);
+ for (uri, text_edits) in changes {
+ let text_edits = text_edits.to_vec();
+ apply_edits(uri, text_edits);
+ }
+ return;
+ // Not sure if it works properly, it'll be safer to just panic here to avoid breaking some parts of code on which code actions will be used
+ // TODO: find some example that uses workspace changes, and test it
+ // for (url, edits) in changes.iter() {
+ // let file_path = url.origin().ascii_serialization();
+ // let file_path = std::path::PathBuf::from(file_path);
+ // let file = std::fs::File::open(file_path).unwrap();
+ // let mut text = Rope::from_reader(file).unwrap();
+ // let transaction = edits_to_changes(&text, edits);
+ // transaction.apply(&mut text);
+ // }
+ }
+
+ if let Some(ref document_changes) = workspace_edit.document_changes {
+ match document_changes {
+ lsp::DocumentChanges::Edits(document_edits) => {
+ for document_edit in document_edits {
+ let edits = document_edit
+ .edits
+ .iter()
+ .map(|edit| match edit {
+ lsp::OneOf::Left(text_edit) => text_edit,
+ lsp::OneOf::Right(annotated_text_edit) => {
+ &annotated_text_edit.text_edit
+ }
+ })
+ .cloned()
+ .collect();
+ apply_edits(&document_edit.text_document.uri, edits);
+ }
+ }
+ lsp::DocumentChanges::Operations(operations) => {
+ log::debug!("document changes - operations: {:?}", operations);
+ for operateion in operations {
+ match operateion {
+ lsp::DocumentChangeOperation::Op(op) => {
+ apply_document_resource_op(op).unwrap();
+ }
+
+ lsp::DocumentChangeOperation::Edit(document_edit) => {
+ let edits = document_edit
+ .edits
+ .iter()
+ .map(|edit| match edit {
+ lsp::OneOf::Left(text_edit) => text_edit,
+ lsp::OneOf::Right(annotated_text_edit) => {
+ &annotated_text_edit.text_edit
+ }
+ })
+ .cloned()
+ .collect();
+ apply_edits(&document_edit.text_document.uri, edits);
+ }
+ }
+ }
+ }
+ }
+ }
+}
+fn goto_impl(
+ editor: &mut Editor,
+ compositor: &mut Compositor,
+ locations: Vec<lsp::Location>,
+ offset_encoding: OffsetEncoding,
+) {
+ push_jump(editor);
+
+ // TODO: share with symbol picker(symbol.location)
+ fn jump_to(
+ editor: &mut Editor,
+ location: &lsp::Location,
+ offset_encoding: OffsetEncoding,
+ action: Action,
+ ) {
+ let path = location
+ .uri
+ .to_file_path()
+ .expect("unable to convert URI to filepath");
+ let _id = editor.open(path, action).expect("editor.open failed");
+ let (view, doc) = current!(editor);
+ let definition_pos = location.range.start;
+ // TODO: convert inside server
+ let new_pos =
+ if let Some(new_pos) = lsp_pos_to_pos(doc.text(), definition_pos, offset_encoding) {
+ new_pos
+ } else {
+ return;
+ };
+ doc.set_selection(view.id, Selection::point(new_pos));
+ align_view(doc, view, Align::Center);
+ }
+
+ let cwdir = std::env::current_dir().expect("couldn't determine current directory");
+
+ match locations.as_slice() {
+ [location] => {
+ jump_to(editor, location, offset_encoding, Action::Replace);
+ }
+ [] => {
+ editor.set_error("No definition found.");
+ }
+ _locations => {
+ let picker = FilePicker::new(
+ locations,
+ move |location| {
+ let file: Cow<'_, str> = (location.uri.scheme() == "file")
+ .then(|| {
+ location
+ .uri
+ .to_file_path()
+ .map(|path| {
+ // strip root prefix
+ path.strip_prefix(&cwdir)
+ .map(|path| path.to_path_buf())
+ .unwrap_or(path)
+ })
+ .map(|path| Cow::from(path.to_string_lossy().into_owned()))
+ .ok()
+ })
+ .flatten()
+ .unwrap_or_else(|| location.uri.as_str().into());
+ let line = location.range.start.line;
+ format!("{}:{}", file, line).into()
+ },
+ move |cx, location, action| jump_to(cx.editor, location, offset_encoding, action),
+ |_editor, location| {
+ // TODO: share code for symbol.location and location
+ let path = location.uri.to_file_path().unwrap();
+ let line = Some((
+ location.range.start.line as usize,
+ location.range.end.line as usize,
+ ));
+ Some((path, line))
+ },
+ );
+ compositor.push(Box::new(overlayed(picker)));
+ }
+ }
+}
+
+pub fn goto_definition(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ let offset_encoding = language_server.offset_encoding();
+
+ let pos = pos_to_lsp_pos(
+ doc.text(),
+ doc.selection(view.id)
+ .primary()
+ .cursor(doc.text().slice(..)),
+ offset_encoding,
+ );
+
+ let future = language_server.goto_definition(doc.identifier(), pos, None);
+
+ cx.callback(
+ future,
+ move |editor: &mut Editor,
+ compositor: &mut Compositor,
+ response: Option<lsp::GotoDefinitionResponse>| {
+ let items = match response {
+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],
+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,
+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations
+ .into_iter()
+ .map(|location_link| lsp::Location {
+ uri: location_link.target_uri,
+ range: location_link.target_range,
+ })
+ .collect(),
+ None => Vec::new(),
+ };
+
+ goto_impl(editor, compositor, items, offset_encoding);
+ },
+ );
+}
+
+pub fn goto_type_definition(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ let offset_encoding = language_server.offset_encoding();
+
+ let pos = pos_to_lsp_pos(
+ doc.text(),
+ doc.selection(view.id)
+ .primary()
+ .cursor(doc.text().slice(..)),
+ offset_encoding,
+ );
+
+ let future = language_server.goto_type_definition(doc.identifier(), pos, None);
+
+ cx.callback(
+ future,
+ move |editor: &mut Editor,
+ compositor: &mut Compositor,
+ response: Option<lsp::GotoDefinitionResponse>| {
+ let items = match response {
+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],
+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,
+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations
+ .into_iter()
+ .map(|location_link| lsp::Location {
+ uri: location_link.target_uri,
+ range: location_link.target_range,
+ })
+ .collect(),
+ None => Vec::new(),
+ };
+
+ goto_impl(editor, compositor, items, offset_encoding);
+ },
+ );
+}
+
+pub fn goto_implementation(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ let offset_encoding = language_server.offset_encoding();
+
+ let pos = pos_to_lsp_pos(
+ doc.text(),
+ doc.selection(view.id)
+ .primary()
+ .cursor(doc.text().slice(..)),
+ offset_encoding,
+ );
+
+ let future = language_server.goto_implementation(doc.identifier(), pos, None);
+
+ cx.callback(
+ future,
+ move |editor: &mut Editor,
+ compositor: &mut Compositor,
+ response: Option<lsp::GotoDefinitionResponse>| {
+ let items = match response {
+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],
+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,
+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations
+ .into_iter()
+ .map(|location_link| lsp::Location {
+ uri: location_link.target_uri,
+ range: location_link.target_range,
+ })
+ .collect(),
+ None => Vec::new(),
+ };
+
+ goto_impl(editor, compositor, items, offset_encoding);
+ },
+ );
+}
+
+pub fn goto_reference(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ let offset_encoding = language_server.offset_encoding();
+
+ let pos = pos_to_lsp_pos(
+ doc.text(),
+ doc.selection(view.id)
+ .primary()
+ .cursor(doc.text().slice(..)),
+ offset_encoding,
+ );
+
+ let future = language_server.goto_reference(doc.identifier(), pos, None);
+
+ cx.callback(
+ future,
+ move |editor: &mut Editor,
+ compositor: &mut Compositor,
+ items: Option<Vec<lsp::Location>>| {
+ goto_impl(
+ editor,
+ compositor,
+ items.unwrap_or_default(),
+ offset_encoding,
+ );
+ },
+ );
+}
+
+pub fn signature_help(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ let pos = pos_to_lsp_pos(
+ doc.text(),
+ doc.selection(view.id)
+ .primary()
+ .cursor(doc.text().slice(..)),
+ language_server.offset_encoding(),
+ );
+
+ let future = language_server.text_document_signature_help(doc.identifier(), pos, None);
+
+ cx.callback(
+ future,
+ move |_editor: &mut Editor,
+ _compositor: &mut Compositor,
+ response: Option<lsp::SignatureHelp>| {
+ if let Some(signature_help) = response {
+ log::info!("{:?}", signature_help);
+ // signatures
+ // active_signature
+ // active_parameter
+ // render as:
+
+ // signature
+ // ----------
+ // doc
+
+ // with active param highlighted
+ }
+ },
+ );
+}
+pub fn hover(cx: &mut Context) {
+ let (view, doc) = current!(cx.editor);
+
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ // TODO: factor out a doc.position_identifier() that returns lsp::TextDocumentPositionIdentifier
+
+ let pos = pos_to_lsp_pos(
+ doc.text(),
+ doc.selection(view.id)
+ .primary()
+ .cursor(doc.text().slice(..)),
+ language_server.offset_encoding(),
+ );
+
+ let future = language_server.text_document_hover(doc.identifier(), pos, None);
+
+ cx.callback(
+ future,
+ move |editor: &mut Editor, compositor: &mut Compositor, response: Option<lsp::Hover>| {
+ if let Some(hover) = response {
+ // hover.contents / .range <- used for visualizing
+
+ fn marked_string_to_markdown(contents: lsp::MarkedString) -> String {
+ match contents {
+ lsp::MarkedString::String(contents) => contents,
+ lsp::MarkedString::LanguageString(string) => {
+ if string.language == "markdown" {
+ string.value
+ } else {
+ format!("```{}\n{}\n```", string.language, string.value)
+ }
+ }
+ }
+ }
+
+ let contents = match hover.contents {
+ lsp::HoverContents::Scalar(contents) => marked_string_to_markdown(contents),
+ lsp::HoverContents::Array(contents) => contents
+ .into_iter()
+ .map(marked_string_to_markdown)
+ .collect::<Vec<_>>()
+ .join("\n\n"),
+ lsp::HoverContents::Markup(contents) => contents.value,
+ };
+
+ // skip if contents empty
+
+ let contents =
+ ui::Markdown::new(contents, editor.syn_loader.clone()).style_group("hover");
+ let popup = Popup::new("hover", contents);
+ compositor.replace_or_push("hover", Box::new(popup));
+ }
+ },
+ );
+}
+pub fn rename_symbol(cx: &mut Context) {
+ let prompt = Prompt::new(
+ "rename-to:".into(),
+ None,
+ ui::completers::none,
+ move |cx: &mut compositor::Context, input: &str, event: PromptEvent| {
+ if event != PromptEvent::Validate {
+ return;
+ }
+
+ log::debug!("renaming to: {:?}", input);
+
+ let (view, doc) = current!(cx.editor);
+ let language_server = match doc.language_server() {
+ Some(language_server) => language_server,
+ None => return,
+ };
+
+ let offset_encoding = language_server.offset_encoding();
+
+ let pos = pos_to_lsp_pos(
+ doc.text(),
+ doc.selection(view.id)
+ .primary()
+ .cursor(doc.text().slice(..)),
+ offset_encoding,
+ );
+
+ let task = language_server.rename_symbol(doc.identifier(), pos, input.to_string());
+ let edits = block_on(task).unwrap_or_default();
+ log::debug!("Edits from LSP: {:?}", edits);
+ apply_workspace_edit(cx.editor, offset_encoding, &edits);
+ },
+ );
+ cx.push_layer(Box::new(prompt));
+}
generated by cgit v1.2.3-70-g09d2 (git 2.47.1) at 2024-12-28 13:50:08 +0000