use helix_lsp::{

block_on,

lsp::{

NumberOrString,

},

util::{diagnostic_to_lsp_diagnostic, lsp_range_to_range, range_to_lsp_range},

};

use tokio_stream::StreamExt;

use super::{align_view, push_jump, Align, Context, Editor};

use helix_stdx::path;

use helix_view::{

document::{DocumentInlayHints, DocumentInlayHintsId},

editor::Action,

handlers::lsp::SignatureHelpInvoked,

theme::Style,

Document, View,

use crate::{

compositor::{self, Compositor},

job::Callback,

};

/// Gets the first language server that is attached to a document which supports a specific feature.

/// If there is no configured language server that supports the feature, this displays a status message.

match language_server {

Some(language_server) => language_server,

None => {

"No configured language server supports {}",

$feature

));

}};

}

}

}

struct SymbolInformationItem {

symbol: lsp::SymbolInformation,

}

struct DiagnosticStyles {

}

struct PickerDiagnostic {

diag: lsp::Diagnostic,

}

let line = Some((

location.range.start.line as usize,

location.range.end.line as usize,

));

}

let (view, doc) = current!(editor);

push_jump(view, doc);

};

Ok(id) => doc_mut!(editor, &id),

Err(err) => {

editor.set_error(err);

return;

}

};

let view = view_mut!(editor);

// TODO: convert inside server

// 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(new_range.head, new_range.anchor));

}

}

}

#[derive(Copy, Clone, PartialEq)]

HideSourcePath,

}

fn diag_picker(

cx: &Context,

format: DiagnosticsFormat,

// TODO: drop current_path comparison and instead use workspace: bool flag?

// flatten the map to a vec of (url, diag) pairs

let mut flat_diag = Vec::new();

flat_diag.reserve(diags.len());

flat_diag.push(PickerDiagnostic {

diag,

});

}

}

}

let styles = DiagnosticStyles {

hint: cx.editor.theme.get("hint"),

info: cx.editor.theme.get("info"),

error: cx.editor.theme.get("error"),

};

Picker::new(

flat_diag,

},

)

.truncate_start(false)

}

fn nested_to_flat(

list: &mut Vec<SymbolInformationItem>,

file: &lsp::TextDocumentIdentifier,

symbol: lsp::DocumentSymbol,

offset_encoding: OffsetEncoding,

) {

location: lsp::Location::new(file.uri.clone(), symbol.selection_range),

container_name: None,

},

});

for child in symbol.children.into_iter().flatten() {

}

}

let doc = doc!(cx.editor);

let mut seen_language_servers = HashSet::new();

.language_servers_with_feature(LanguageServerFeature::DocumentSymbols)

.filter(|ls| seen_language_servers.insert(ls.id()))

.map(|language_server| {

let request = language_server.document_symbols(doc.identifier()).unwrap();

let offset_encoding = language_server.offset_encoding();

let doc_id = doc.identifier();

async move {

Some(symbols) => symbols,

None => return anyhow::Ok(vec![]),

};

lsp::DocumentSymbolResponse::Flat(symbols) => symbols

.into_iter()

.map(|symbol| SymbolInformationItem {

symbol,

})

.collect(),

lsp::DocumentSymbolResponse::Nested(symbols) => {

let mut flat_symbols = Vec::new();

for symbol in symbols {

}

flat_symbols

}

}

})

.collect();

if futures.is_empty() {

cx.editor

cx.jobs.callback(async move {

let mut symbols = Vec::new();

}

let call = move |_editor: &mut Editor, compositor: &mut Compositor| {

compositor.push(Box::new(overlaid(picker)))

};

}

pub fn workspace_symbol_picker(cx: &mut Context) {

let doc = doc!(cx.editor);

if doc

.language_servers_with_feature(LanguageServerFeature::WorkspaceSymbols)

return;

}

let doc = doc!(editor);

let mut seen_language_servers = HashSet::new();

.language_servers_with_feature(LanguageServerFeature::WorkspaceSymbols)

.filter(|ls| seen_language_servers.insert(ls.id()))

.map(|language_server| {

let offset_encoding = language_server.offset_encoding();

async move {

symbol,

})

anyhow::Ok(response)

}

editor.set_error("No configured language server supports workspace symbols");

}

async move {

}

}

.boxed()

};

}

pub fn diagnostics_picker(cx: &mut Context) {

let doc = doc!(cx.editor);

cx.push_layer(Box::new(overlaid(picker)));

}

}

pub fn workspace_diagnostics_picker(cx: &mut Context) {

// TODO not yet filtered by LanguageServerFeature, need to do something similar as Document::shown_diagnostics here for all open documents

let diagnostics = cx.editor.diagnostics.clone();

cx.push_layer(Box::new(overlaid(picker)));

}

struct CodeActionOrCommandItem {

lsp_item: lsp::CodeActionOrCommand,

}

impl ui::menu::Item for CodeActionOrCommandItem {

type Data = ();

match &self.lsp_item {

lsp::CodeActionOrCommand::CodeAction(action) => action.title.as_str().into(),

lsp::CodeActionOrCommand::Command(command) => command.title.as_str().into(),

let mut seen_language_servers = HashSet::new();

.language_servers_with_feature(LanguageServerFeature::CodeAction)

.filter(|ls| seen_language_servers.insert(ls.id()))

// TODO this should probably already been filtered in something like "language_servers_with_feature"

Some((code_action_request, language_server_id))

})

.map(|(request, ls_id)| async move {

};

// remove disabled code actions

cx.jobs.callback(async move {

let mut actions = Vec::new();

}

let call = move |editor: &mut Editor, compositor: &mut Compositor| {

match &action.lsp_item {

lsp::CodeActionOrCommand::Command(command) => {

log::debug!("code action command: {:?}", command);

}

lsp::CodeActionOrCommand::CodeAction(code_action) => {

log::debug!("code action: {:?}", code_action);

// we support lsp "codeAction/resolve" for `edit` and `command` fields

let mut resolved_code_action = None;

if code_action.edit.is_none() || code_action.command.is_none() {

}

}

}

resolved_code_action.as_ref().unwrap_or(code_action);

if let Some(ref workspace_edit) = resolved_code_action.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 {

}

}

}

});

picker.move_down(); // pre-select the first item

let popup = Popup::new("code-action", picker)

.with_scrollbar(false)

compositor.replace_or_push("code-action", popup);

};

});

}

#[derive(Debug)]

pub struct ApplyEditError {

pub kind: ApplyEditErrorKind,

// InvalidEdit,

}

match self {

}

}

}

let cwdir = helix_stdx::env::current_working_dir();

match locations.as_slice() {

[location] => {

}

_locations => {

})

compositor.push(Box::new(overlaid(picker)));

}

}

}

fn goto_single_impl<P, F>(cx: &mut Context, feature: LanguageServerFeature, request_provider: P)

where

P: Fn(&Client, lsp::Position, lsp::TextDocumentIdentifier) -> Option<F>,

{

}

pub fn goto_declaration(cx: &mut Context) {

pub fn goto_reference(cx: &mut Context) {

let config = cx.editor.config();

}

pub fn signature_help(cx: &mut Context) {

}

pub fn hover(cx: &mut Context) {

let (view, doc) = current!(cx.editor);

}

pub fn rename_symbol(cx: &mut Context) {

fn create_rename_prompt(

editor: &Editor,

prefill: String,

) -> Box<ui::Prompt> {

let prompt = ui::Prompt::new(

"rename-to:".into(),

ui::completers::none,

move |cx: &mut compositor::Context, input: &str, event: PromptEvent| {

if event != PromptEvent::Validate {

let Some(language_server) = doc

.language_servers_with_feature(LanguageServerFeature::RenameSymbol)

else {

cx.editor

.set_error("No configured language server supports symbol renaming");

match block_on(future) {

Ok(edits) => {

}

Err(err) => cx.editor.set_error(err.to_string()),

}

}

let (view, doc) = current_ref!(cx.editor);

if doc

.language_servers_with_feature(LanguageServerFeature::RenameSymbol)

}

};

compositor.push(prompt);

},

);

} else {

let prefill = get_prefill_from_word_boundary(cx.editor);

cx.push_layer(prompt);

}

}

// than computing all the hints for the full file (which could be dozens of time

// longer than the view is).

let view_height = view.inner_height();

let first_line = first_visible_line.saturating_sub(view_height);

let last_line = first_visible_line

.saturating_add(view_height.saturating_mul(2))

if !doc.inlay_hints_oudated

&& doc

.inlay_hints(view_id)

{

return None;

}

// Most language servers will already send them sorted but ensure this is the case to

// avoid errors on our end.

let mut padding_before_inlay_hints = Vec::new();

let mut type_inlay_hints = Vec::new();

let mut padding_after_inlay_hints = Vec::new();

let doc_text = doc.text();

for hint in hints {

let char_idx =

None => continue,

};

lsp::InlayHintLabel::String(s) => s,

lsp::InlayHintLabel::LabelParts(parts) => parts

.into_iter()

.collect::<Vec<_>>()

.join(""),

};

let inlay_hints_vec = match hint.kind {

Some(lsp::InlayHintKind::TYPE) => &mut type_inlay_hints,

view_id,

DocumentInlayHints {

id: new_doc_inlay_hints_id,

},

);

doc.inlay_hints_oudated = false;