[[package]]

name = "bitflags"

version = "2.12.1"

||||||| parent of 527dfbec94 (hmmm2)

version = "2.9.4"

<<<<<<< HEAD

checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"

dependencies = [

"block2",

"libc",

"objc2",

]

[[package]]

name = "getrandom"

version = "0.2.17"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

"arrayvec",

"base-db",

"cfg",

"cov-mark",

"drop_bomb",

dependencies = [

"arrayvec",

"base-db",

"cov-mark",

"either",

"ena",

dependencies = [

"arrayvec",

"base-db",

"cov-mark",

"crossbeam-channel",

"either",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "533e68a5842e734946fe159fb03fc9bbbb254f590dd0d8ad321ae5ff7beca2c1"

dependencies = [

"inotify-sys",

"libc",

]

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "07293a4e297ac234359b510362495713f75ea345d5307140414f20c69ffeb087"

dependencies = [

"libc",

]

[[package]]

name = "lsp-server"

version = "0.7.9"

dependencies = [

"crossbeam-channel",

"log",

"serde",

"serde_derive",

"serde_json",

]

[[package]]

name = "lsp-server"

dependencies = [

"crossbeam-channel",

"log",

"serde",

"serde_derive",

"serde_json",

]

[[package]]

version = "0.0.0"

dependencies = [

"arrayvec",

"cov-mark",

"expect-test",

"intern",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d"

dependencies = [

"cfg-if",

"cfg_aliases",

"libc",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "4d3d07927151ff8575b7087f245456e549fea62edf0ec4e565a5ee50c8402bc3"

dependencies = [

"fsevent-sys",

"inotify",

"kqueue",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "42b8cfee0e339a0337359f3c88165702ac6e600dc01c0cc9579a92d62b08477a"

dependencies = [

]

[[package]]

dependencies = [

"bit-set",

"bit-vec",

"num-traits",

"rand",

"rand_chacha",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b"

dependencies = [

"memchr",

"unicase",

]

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "2f25a779e21ca3bba6795193b16508c8ab159f96ee4b07349893fd272065b525"

dependencies = [

"ra-ap-rustc_hashes",

"ra-ap-rustc_index",

"tracing",

checksum = "8c5d9a4d3e7bee7313599bc6d794037247ac0165f03857379cf4fc3097199e05"

dependencies = [

"arrayvec",

"derive-where",

"ena",

"indexmap",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"

dependencies = [

]

[[package]]

"dirs",

"dissimilar",

"expect-test",

"hir",

"hir-def",

"hir-ty",

"intern",

"itertools 0.15.0",

"load-cargo",

"memchr",

"mimalloc",

"num_cpus",

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "486c2179b4796f65bfe2ee33679acf0927ac83ecf583ad6c91c3b4570911b9ad"

dependencies = [

"smallvec",

]

checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"

>>>>>>> 527dfbec94 (hmmm2)

dependencies = [

"errno",

"libc",

"linux-raw-sys",

[[package]]

name = "serde_json"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

"indexmap",

"itoa",

]

[[package]]

name = "serde_spanned"

<<<<<<< HEAD

version = "1.1.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"

dependencies = [

"hashbrown 0.15.5",

"indexmap",

"semver",

checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"

dependencies = [

"anyhow",

"indexmap",

"log",

"serde",

tracing::info!("InitializeParams: {}", initialize_params);

let lsp_types::InitializeParams {

root_uri,

initialization_options,

client_info,

..

} = from_json::<lsp_types::InitializeParams>("InitializeParams", &initialize_params)?;

let root_path = match root_uri

.and_then(|it| it.to_file_path().ok())

.map(patch_path_prefix)

);

}

.map(|workspaces| {

workspaces

.into_iter()

if !error_sink.is_empty() {

use lsp_types::{

};

let not = lsp_server::Notification::new(

);

connection.sender.send(lsp_server::Message::Notification(not)).unwrap();

}

name: String::from("rust-analyzer"),

version: Some(crate::version().to_string()),

}),

};

let initialize_result = serde_json::to_value(initialize_result).unwrap();

//! LSIF (language server index format) generator

use std::env;

use std::time::Instant;

};

use ide_db::{line_index, line_index::WideEncoding};

use load_cargo::{LoadCargoConfig, ProcMacroServerChoice, load_workspace};

use project_model::{CargoConfig, ProjectManifest, ProjectWorkspace, RustLibSource};

use rustc_hash::FxHashMap;

use stdx::format_to;

use vfs::{AbsPathBuf, Vfs};

use crate::{

cli::flags,

line_index::{LineEndings, LineIndex, PositionEncoding},

#[derive(Clone, Copy)]

struct Id(i32);

fn from(Id(it): Id) -> Self {

}

}

let path = path.as_path().unwrap();

let doc_id = self.add_vertex(lsif::Vertex::Document(lsif::Document {

language_id: "rust".to_owned(),

}));

self.file_map.insert(id, doc_id);

doc_id

if let Some(hover) = token.hover {

let hover_id = self.add_vertex(lsif::Vertex::HoverResult {

result: lsp_types::Hover {

hover.markup,

ide::HoverDocFormat::Markdown,

)),

out_v: result_set_id.into(),

}));

let mut edges = token.references.iter().fold(

|mut edges, it| {

let entry = edges.entry((it.range.file_id, it.is_definition)).or_default();

entry.push((*self.range_map.get(&it.range).unwrap()).into());

let mut lsif = LsifManager::new(&analysis, db, &vfs, out);

lsif.add_vertex(lsif::Vertex::MetaData(lsif::MetaData {

version: String::from("0.5.0"),

position_encoding: lsif::Encoding::Utf16,

name: "rust-analyzer".to_owned(),

args: vec![],

version: Some(version().to_string()),

default_config: &'static DefaultConfigData,

/// Config node that obtains its initial value during the server initialization and

client_config: (FullConfigInput, ConfigErrors),

/// Config node whose values apply to **every** Rust project.

lsp_types::Diagnostic {

range: lsp::to_proto::range(line_index, d.range.range),

severity: Some(lsp::to_proto::diagnostic_severity(d.severity)),

code_description: Some(lsp_types::CodeDescription {

}),

source: Some("rust-analyzer".to_owned()),

message: d.message,

related_information: None,

data: None,

}

}

code: Option<&crate::flycheck::DiagnosticCode>,

) -> Option<lsp_types::DiagnosticSeverity> {

let res = match level {

DiagnosticLevel::Warning => match code {

// HACK: special case for `warnings` rustc lint.

Some(code)

lint == "warnings" || ide_db::helpers::lint_eq_or_in_group(&code.code, lint)

}) =>

{

}

// HACK: special case for `warnings` rustc lint.

Some(code)

lint == "warnings" || ide_db::helpers::lint_eq_or_in_group(&code.code, lint)

}) =>

{

}

},

_ => return None,

};

Some(res)

return MappedRustChildDiagnostic::MessageLine(rd.message.clone());

}

let mut suggested_replacements = Vec::new();

let mut is_preferred = true;

for &span in &spans {

action: lsp_ext::CodeAction {

title: message.clone(),

group: None,

edit: Some(lsp_ext::SnippetWorkspaceEdit {

// FIXME: there's no good reason to use edit_map here....

changes: Some(edit_map),

#[derive(Debug)]

pub(crate) struct MappedRustDiagnostic {

pub(crate) diagnostic: lsp_types::Diagnostic,

pub(crate) fix: Option<Box<Fix>>,

}

match &*code.code {

"dead_code" | "unknown_lints" | "unreachable_code" | "unused_attributes"

| "unused_imports" | "unused_macros" | "unused_variables" => {

}

"deprecated" => {

}

_ => {}

}

let diagnostic = lsp_types::Diagnostic {

range: secondary_location.range,

// downgrade to hint if we're pointing at the macro

code_description: code_description.clone(),

source: Some(source.to_owned()),

message: message.clone(),

related_information: Some(information_for_additional_diagnostic),

data: Some(serde_json::json!({ "rendered": rendered })),

};

diagnostics.push(MappedRustDiagnostic {

diagnostic: lsp_types::Diagnostic {

range: primary_location.range,

severity,

code_description: code_description.clone(),

source: Some(source.to_owned()),

message,

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

if info.is_empty() { None } else { Some(info) }

},

data: Some(serde_json::json!({ "rendered": rendered })),

},

// i dont like it.

fix: sub.suggested_fix.clone(),

diagnostic: lsp_types::Diagnostic {

range: sub.related.location.range,

code_description: code_description.clone(),

source: Some(source.to_owned()),

message: sub.related.message.clone(),

&& chars.next().is_none()

})

.and_then(|code| {

.ok()

.map(|href| lsp_types::CodeDescription { href })

})

fn clippy_code_description(code: Option<&str>) -> Option<lsp_types::CodeDescription> {

code.and_then(|code| {

"https://rust-lang.github.io/rust-clippy/master/index.html#{code}"

))

.ok()

"clippy",

),

message: "this argument is passed by reference, but would be more efficient if passed by value\n#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\nfor further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"clippy",

),

message: "lint level defined here",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"clippy",

),

message: "consider passing by value instead: `self`",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "can't compare `{integer}` with `&str`\nthe trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",

related_information: None,

data: None,

},

fix: None,

"rustc",

),

message: "Please register your known path in the path module",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "Please register your known path in the path module",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "Please register your known path in the path module",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "`main` function not found in crate `current`\nconsider adding a `main` function to `src/bin/current.rs`",

related_information: None,

data: None,

},

fix: None,

"rustc",

),

message: "method `next` has an incompatible type for trait\nexpected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`",

related_information: None,

data: None,

},

fix: None,

"rustc",

),

message: "mismatched types\nexpected usize, found u32",

related_information: None,

data: None,

},

fix: None,

"rustc",

),

message: "mismatched types\nexpected `u32`, found `&str`",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "expected due to this",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "consider prefixing with an underscore: `_foo`",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: Some(

title: "consider prefixing with an underscore: `_foo`",

group: None,

kind: Some(

),

command: None,

edit: Some(

"rustc",

),

message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "consider prefixing with an underscore: `_foo`",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: Some(

title: "consider prefixing with an underscore: `_foo`",

group: None,

kind: Some(

),

command: None,

edit: Some(

"rustc",

),

message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "consider prefixing with an underscore: `_foo`",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: Some(

title: "consider prefixing with an underscore: `_foo`",

group: None,

kind: Some(

),

command: None,

edit: Some(

"rustc",

),

message: "this function takes 2 parameters but 3 parameters were supplied\nexpected 2 parameters",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"rustc",

),

message: "defined here",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"clippy",

),

message: "returning the result of a let binding from a block\n`#[warn(clippy::let_and_return)]` on by default\nfor further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"clippy",

),

message: "unnecessary let binding",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: None,

"clippy",

),

message: "return the expression directly: `(0..10).collect()`",

related_information: Some(

[

DiagnosticRelatedInformation {

},

],

),

data: None,

},

fix: Some(

title: "return the expression directly: `(0..10).collect()`",

group: None,

kind: Some(

),

command: None,

edit: Some(

};

use itertools::Itertools;

use load_cargo::SourceRootConfig;

use parking_lot::{

MappedRwLockReadGuard, Mutex, RwLock, RwLockReadGuard, RwLockUpgradableReadGuard,

RwLockWriteGuard,

pub(crate) source_root_config: SourceRootConfig,

/// A mapping that maps a local source root's `SourceRootId` to it parent's `SourceRootId`, if it has one.

pub(crate) local_roots_parent_map: Arc<FxHashMap<SourceRootId, SourceRootId>>,

// status

pub(crate) shutdown_requested: bool,

pub(crate) analysis: Analysis,

pub(crate) check_fixes: CheckFixes,

mem_docs: MemDocs,

vfs: Arc<RwLock<(vfs::Vfs, FxHashMap<FileId, LineEndings>)>>,

pub(crate) workspaces: Arc<Vec<ProjectWorkspace>>,

// used to signal semantic highlighting to fall back to syntax based highlighting until

}

}

&mut self,

params: R::Params,

handler: ReqHandler,

) {

self.send(request.into());

}

handler(self, response)

}

self.send(not.into());

}

pub(crate) fn publish_diagnostics(

&mut self,

version: Option<i32>,

mut diagnostics: Vec<lsp_types::Diagnostic>,

) {

}

let not = lsp_server::Notification::new(

lsp_types::PublishDiagnosticsParams { uri, diagnostics, version },

);

_ = sender.send(not.into());

}

/// Returns `None` if the file was excluded.

url_to_file_id(&self.vfs_read(), url)

}

file_id_to_url(&self.vfs_read(), id)

}

Some(self.mem_docs.get(self.vfs_read().file_path(file_id))?.version)

}

let path = from_proto::vfs_path(url).ok()?;

Some(self.mem_docs.get(&path)?.version)

}

let mut base = self.vfs_read().file_path(path.anchor).clone();

base.pop();

let path = base.join(&path.path).unwrap();

}

}

let path = vfs.file_path(id);

let path = path.as_path().unwrap();

url_from_abs_path(path)

}

/// Returns `None` if the file was excluded.

let path = from_proto::vfs_path(url)?;

vfs_path_to_file_id(vfs, &path)

}

f: fn(&mut GlobalState, R::Params) -> anyhow::Result<R::Result>,

) -> &mut Self

where

R::Params: DeserializeOwned + panic::UnwindSafe + fmt::Debug,

R::Result: Serialize,

{

f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,

) -> &mut Self

where

R::Params: DeserializeOwned + panic::UnwindSafe + fmt::Debug,

R::Result: Serialize,

{

f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,

) -> &mut Self

where

Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,

Result: Serialize + Default,

> + 'static,

{

if !self.global_state.vfs_done {

if let Some(lsp_server::Request { id, .. }) =

{

self.global_state.respond(lsp_server::Response::new_ok(id, R::Result::default()));

}

on_cancelled: fn() -> ResponseError,

) -> &mut Self

where

Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,

Result: Serialize,

> + 'static,

{

if !self.global_state.vfs_done || self.global_state.incomplete_crate_graph {

if let Some(lsp_server::Request { id, .. }) =

{

self.global_state.respond(lsp_server::Response::new_ok(id, default()));

}

f: fn(GlobalStateSnapshot, Params) -> anyhow::Result<R::Result>,

) -> &mut Self

where

Params: Serialize + DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,

{

if !self.global_state.vfs_done {

f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,

) -> &mut Self

where

Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,

Result: Serialize + Default,

> + 'static,

{

if !self.global_state.vfs_done {

if let Some(lsp_server::Request { id, .. }) =

{

self.global_state.respond(lsp_server::Response::new_ok(id, R::Result::default()));

}

f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,

) -> &mut Self

where

R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,

R::Result: Serialize,

{

on_cancelled: fn() -> ResponseError,

) -> &mut Self

where

R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,

R::Result: Serialize,

{

fn parse<R>(&mut self) -> Option<(lsp_server::Request, R::Params, String)>

where

R::Params: DeserializeOwned + fmt::Debug,

{

match res {

Ok(params) => {

let panic_context =

result: thread::Result<anyhow::Result<R::Result>>,

) -> Result<lsp_server::Response, HandlerCancelledError>

where

R::Params: DeserializeOwned,

R::Result: Serialize,

{

result: anyhow::Result<R::Result>,

) -> Result<lsp_server::Response, HandlerCancelledError>

where

R::Params: DeserializeOwned,

R::Result: Serialize,

{

f: fn(&mut GlobalState, N::Params) -> anyhow::Result<()>,

) -> &mut Self

where

N::Params: DeserializeOwned + Send + Debug,

{

let not = match self.not.take() {

let _guard = tracing::info_span!("notification", method = ?not.method).entered();

Ok(it) => it,

Err(ExtractError::JsonError { method, error }) => {

tracing::error!(method = %method, error = %error, "invalid notification");

pub(crate) fn handle_cancel(state: &mut GlobalState, params: CancelParams) -> anyhow::Result<()> {

let id: lsp_server::RequestId = match params.id {

};

state.cancel(id);

Ok(())

state: &mut GlobalState,

params: WorkDoneProgressCancelParams,

) -> anyhow::Result<()> {

&& let Some(id) = s.strip_prefix("rust-analyzer/flycheck/")

&& let Ok(id) = id.parse::<u32>()

&& let Some(flycheck) = state.flycheck.get(id as usize)

) -> anyhow::Result<()> {

let _p = tracing::info_span!("handle_did_change_text_document").entered();

let Some(DocumentData { version, data }) = state.mem_docs.get_mut(&path) else {

tracing::error!(?path, "unexpected DidChangeTextDocument");

return Ok(());

) -> anyhow::Result<()> {

// As stated in https://github.com/microsoft/language-server-protocol/issues/676,

// this notification's parameters should be ignored and the actual config queried separately.

lsp_types::ConfigurationParams {

items: vec![lsp_types::ConfigurationItem {

scope_uri: None,

pub(crate) fn handle_abort_run_test(state: &mut GlobalState, _: ()) -> anyhow::Result<()> {

if state.test_run_session.take().is_some() {

}

Ok(())

}

use lsp_types::{

CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,

CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,

};

use paths::Utf8PathBuf;

use project_model::{CargoWorkspace, ManifestPath, ProjectWorkspaceKind, TargetKind};

params: lsp_types::TextDocumentPositionParams,

) -> anyhow::Result<String> {

let _p = tracing::info_span!("handle_view_hir").entered();

let res = snap.analysis.view_hir(position)?;

Ok(res)

}

params: lsp_types::TextDocumentPositionParams,

) -> anyhow::Result<String> {

let _p = tracing::info_span!("handle_view_mir").entered();

let res = snap.analysis.view_mir(position)?;

Ok(res)

}

params: lsp_types::TextDocumentPositionParams,

) -> anyhow::Result<String> {

let _p = tracing::info_span!("handle_interpret_function").entered();

let res = snap.analysis.interpret_function(position)?;

Ok(res)

}

params: lsp_ext::RunTestParams,

) -> anyhow::Result<()> {

if let Some(_session) = state.test_run_session.take() {

}

let mut handles = vec![];

let line_index = snap.file_line_index(file_id)?;

let res: anyhow::Result<Vec<lsp_types::SelectionRange>> = params

.positions

.map(|position| {

let mut ranges = Vec::new();

{

let mut range = TextRange::new(offset, offset);

let line_index = snap.file_line_index(file_id)?;

params

.positions

.map(|position| {

offset.map(|offset| {

match snap.analysis.matching_brace(FilePosition { file_id, offset }) {

Ok(Some(x)) => Some(to_proto::position(&line_index, x)),

params: lsp_types::TextDocumentPositionParams,

) -> anyhow::Result<Option<Vec<lsp_ext::SnippetTextEdit>>> {

let _p = tracing::info_span!("handle_on_enter").entered();

let edit = match snap.analysis.on_enter(position)? {

None => return Ok(None),

Some(it) => it,

if !snap.config.typing_trigger_chars().contains(char_typed) {

return Ok(None);

}

let line_index = snap.file_line_index(position.file_id)?;

// in `ide`, the `on_type` invariant is that

Ok(Some(change))

}

lsp_types::RelatedFullDocumentDiagnosticReport {

related_documents: None,

full_document_diagnostic_report: lsp_types::FullDocumentDiagnosticReport {

items: vec![],

},

},

}

pub(crate) fn handle_document_diagnostics(

snap: GlobalStateSnapshot,

params: lsp_types::DocumentDiagnosticParams,

let file_id = match from_proto::file_id(&snap, &params.text_document.uri)? {

Some(it) => it,

None => return Ok(empty_diagnostic_report()),

}

None

});

full_document_diagnostic_report: lsp_types::FullDocumentDiagnosticReport {

result_id: Some("rust-analyzer".to_owned()),

items: diagnostics.collect(),

.map(|(id, (items, _))| {

(

to_proto::url(&snap, id),

lsp_types::FullDocumentDiagnosticReport {

result_id: Some("rust-analyzer".to_owned()),

items,

})

.collect()

}),

))

}

for node in structure_nodes {

let mut tags = Vec::new();

if node.deprecated {

};

#[allow(deprecated)]

fn flatten_document_symbol(

symbol: &lsp_types::DocumentSymbol,

container_name: Option<String>,

res: &mut Vec<SymbolInformation>,

) {

#[allow(deprecated)]

res.push(SymbolInformation {

deprecated: symbol.deprecated,

location: Location::new(url.clone(), symbol.range),

});

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

res = exec_query(&snap, Query::new(params.query), config.search_limit)?;

}

fn decide_search_kind_and_scope(

params: &WorkspaceSymbolParams,

let container_name = nav.container_name.as_ref().map(|v| v.to_string());

let info = lsp_types::WorkspaceSymbol {

},

};

res.push(info);

}

.files

.into_iter()

.filter_map(|file_rename| {

let from_path = from.to_file_path().ok()?;

let to_path = to.to_file_path().ok()?;

pub(crate) fn handle_goto_definition(

snap: GlobalStateSnapshot,

let _p = tracing::info_span!("handle_goto_definition").entered();

let position =

let config = snap.config.goto_definition(snap.minicore());

let nav_info = match snap.analysis.goto_definition(position, &config)? {

None => return Ok(None),

pub(crate) fn handle_goto_declaration(

snap: GlobalStateSnapshot,

let _p = tracing::info_span!("handle_goto_declaration").entered();

let config = snap.config.goto_definition(snap.minicore());

let nav_info = match snap.analysis.goto_declaration(position, &config)? {

Some(it) => it,

};

let src = FileRange { file_id: position.file_id, range: nav_info.range };

Ok(Some(res))

}

pub(crate) fn handle_goto_implementation(

snap: GlobalStateSnapshot,

let _p = tracing::info_span!("handle_goto_implementation").entered();

let position =

let nav_info =

match snap.analysis.goto_implementation(&snap.config.goto_implementation(), position)? {

None => return Ok(None),

Some(it) => it,

};

let src = FileRange { file_id: position.file_id, range: nav_info.range };

Ok(Some(res))

}

pub(crate) fn handle_goto_type_definition(

snap: GlobalStateSnapshot,

let _p = tracing::info_span!("handle_goto_type_definition").entered();

let position =

let nav_info = match snap.analysis.goto_type_definition(position)? {

None => return Ok(None),

Some(it) => it,

};

let src = FileRange { file_id: position.file_id, range: nav_info.range };

Ok(Some(res))

}

pub(crate) fn handle_parent_module(

snap: GlobalStateSnapshot,

params: lsp_types::TextDocumentPositionParams,

let _p = tracing::info_span!("handle_parent_module").entered();

if let Ok(file_path) = &params.text_document.uri.to_file_path() {

if file_path.file_name().unwrap_or_default() == "Cargo.toml" {

}

// locate parent module by semantics

let navs = snap.analysis.parent_module(position)?;

let res = to_proto::goto_definition_response(&snap, None, navs)?;

Ok(Some(res))

pub(crate) fn handle_child_modules(

snap: GlobalStateSnapshot,

params: lsp_types::TextDocumentPositionParams,

let _p = tracing::info_span!("handle_child_modules").entered();

// locate child module by semantics

let navs = snap.analysis.child_modules(position)?;

let res = to_proto::goto_definition_response(&snap, None, navs)?;

Ok(Some(res))

params: lsp_types::TextDocumentPositionParams,

) -> anyhow::Result<Vec<lsp_ext::TestInfo>> {

let _p = tracing::info_span!("handle_related_tests").entered();

let tests = snap.analysis.related_tests(position, None)?;

let mut res = Vec::new();

pub(crate) fn handle_completion(

snap: GlobalStateSnapshot,

lsp_types::CompletionParams {

context,

..

}: lsp_types::CompletionParams,

) -> anyhow::Result<Option<lsp_types::CompletionResponse>> {

let _p = tracing::info_span!("handle_completion").entered();

let mut position =

let line_index = snap.file_line_index(position.file_id)?;

let completion_trigger_character =

context.and_then(|ctx| ctx.trigger_character).and_then(|s| s.chars().next());

&completion_config.fields_to_resolve,

&line_index,

snap.file_version(position.file_id),

completion_trigger_character,

items,

);

Ok(Some(completion_list.into()))

}

&forced_resolve_completions_config.fields_to_resolve,

&line_index,

snap.file_version(position.file_id),

resolve_data.trigger_character,

vec![corresponding_completion],

);

) -> anyhow::Result<Option<lsp_types::SignatureHelp>> {

let _p = tracing::info_span!("handle_signature_help").entered();

let position =

let help = match snap.analysis.signature_help(position)? {

Some(it) => it,

None => return Ok(None),

let markup_kind = hover.format;

let hover = lsp_ext::Hover {

hover: lsp_types::Hover {

info.info.markup,

markup_kind,

)),

pub(crate) fn handle_prepare_rename(

snap: GlobalStateSnapshot,

let _p = tracing::info_span!("handle_prepare_rename").entered();

let change = snap.analysis.prepare_rename(position)?.map_err(to_proto::rename_error)?;

let line_index = snap.file_line_index(position.file_id)?;

let range = to_proto::range(&line_index, change.range);

}

pub(crate) fn handle_rename(

params: RenameParams,

) -> anyhow::Result<Option<WorkspaceEdit>> {

let _p = tracing::info_span!("handle_rename").entered();

let source_root = snap.analysis.source_root_id(position.file_id).ok();

let config = snap.config.rename(source_root);

let workspace_edit = to_proto::workspace_edit(&snap, change)?;

}

}

params: lsp_types::ReferenceParams,

) -> anyhow::Result<Option<Vec<Location>>> {

let _p = tracing::info_span!("handle_references").entered();

let exclude_imports = snap.config.find_all_refs_exclude_imports();

let exclude_tests = snap.config.find_all_refs_exclude_tests();

) -> anyhow::Result<Option<Vec<lsp_types::TextEdit>>> {

let _p = tracing::info_span!("handle_formatting").entered();

}

pub(crate) fn handle_range_formatting(

) -> anyhow::Result<Option<Vec<lsp_types::TextEdit>>> {

let _p = tracing::info_span!("handle_range_formatting").entered();

}

pub(crate) fn handle_code_action(

let changes = code_action.edit.as_ref().and_then(|it| it.document_changes.as_ref());

if let Some(changes) = changes {

for change in changes {

}

}

}

&& let Some(changes) = edit.document_changes.as_ref()

{

for change in changes {

}

}

}

) -> anyhow::Result<Option<Vec<lsp_types::DocumentHighlight>>> {

let _p = tracing::info_span!("handle_document_highlight").entered();

let position =

let line_index = snap.file_line_index(position.file_id)?;

let source_root = snap.analysis.source_root_id(position.file_id)?;

.map(|range| from_proto::file_range(&snap, &params.position.text_document, *range))

.collect::<Result<Option<Vec<_>>, _>>()?

);

let source_change = snap.analysis.structural_search_replace(

&params.query,

params.parse_only,

) -> anyhow::Result<Option<Vec<CallHierarchyItem>>> {

let _p = tracing::info_span!("handle_call_hierarchy_prepare").entered();

let position =

let config = snap.config.call_hierarchy(snap.minicore());

let nav_info = match snap.analysis.call_hierarchy(position, &config)? {

Some(it) => it,

};

}

pub(crate) fn handle_call_hierarchy_outgoing(

pub(crate) fn handle_semantic_tokens_full(

snap: GlobalStateSnapshot,

params: SemanticTokensParams,

let _p = tracing::info_span!("handle_semantic_tokens_full").entered();

let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

// Unconditionally cache the tokens

snap.semantic_tokens_cache.lock().insert(params.text_document.uri, semantic_tokens.clone());

}

pub(crate) fn handle_semantic_tokens_full_delta(

snap: GlobalStateSnapshot,

params: SemanticTokensDeltaParams,

let _p = tracing::info_span!("handle_semantic_tokens_full_delta").entered();

let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

pub(crate) fn handle_semantic_tokens_range(

snap: GlobalStateSnapshot,

params: SemanticTokensRangeParams,

let _p = tracing::info_span!("handle_semantic_tokens_range").entered();

let frange = try_default!(from_proto::file_range(&snap, &params.text_document, params.range)?);

snap.config.semantics_tokens_augments_syntax_tokens(),

snap.config.highlighting_non_standard_tokens(),

);

}

pub(crate) fn handle_open_docs(

params: lsp_types::TextDocumentPositionParams,

) -> anyhow::Result<ExternalDocsResponse> {

let _p = tracing::info_span!("handle_open_docs").entered();

let ws_and_sysroot = snap.workspaces.iter().find_map(|ws| match &ws.kind {

ProjectWorkspaceKind::Cargo { cargo, .. }

};

};

if snap.config.local_docs() {

Ok(ExternalDocsResponse::WithLocal(ExternalDocsPair { web, local }))

pub(crate) fn handle_open_cargo_toml(

snap: GlobalStateSnapshot,

params: lsp_ext::OpenCargoTomlParams,

let _p = tracing::info_span!("handle_open_cargo_toml").entered();

let file_id = try_default!(from_proto::file_id(&snap, &params.text_document.uri)?);

};

let cargo_toml_url = to_proto::url_from_abs_path(&cargo_spec.cargo_toml);

Ok(Some(res))

}

let locations: Vec<_> = nav_data

.info

.into_iter()

.collect();

let title = to_proto::implementation_title(locations.len());

let command = to_proto::command::show_references(title, &uri, position, locations);

fn run_rustfmt(

snap: &GlobalStateSnapshot,

range: Option<lsp_types::Range>,

) -> anyhow::Result<Option<Vec<lsp_types::TextEdit>>> {

let file_id = try_default!(from_proto::file_id(snap, &text_document.uri)?);

.into());

}

let start_line = line_index.index.line_col(frange.range.start()).line;

let end_line = line_index.index.line_col(frange.range.end()).line;

None

}

let path = path.as_path()?;

let str_path = path.as_os_str().to_str()?;

}

{

return Err(LspError::new(

ErrorCode::RequestFailed as i32,

format!(

"Client does not support {} capability.",

ResourceOperationKind::Create => "create",

ResourceOperationKind::Rename => "rename",

ResourceOperationKind::Delete => "delete",

Ok(())

}

pub(crate) fn diff(left: &str, right: &str) -> TextEdit {

use dissimilar::Chunk;

pub mod config;

mod global_state;

pub mod lsp;

use self::lsp::ext as lsp_ext;

#[cfg(test)]

version::version,

};

serde_json::from_value(json.clone())

.map_err(|e| anyhow::format_err!("Failed to deserialize {what}: {e}; {json}"))

}

use ide::{CompletionFieldsToResolve, InlayFieldsToResolve};

use ide_db::{FxHashSet, line_index::WideEncoding};

use lsp_types::{

};

use serde_json::json;

_ => None,

},

},

open_close: Some(true),

will_save: None,

will_save_wait_until: None,

save: if config.caps().did_save_text_document_dynamic_registration() {

Some(SaveOptions::default().into())

},

})),

completion_provider: Some(CompletionOptions {

resolve_provider: if config.client_is_neovim() {

config.has_completion_item_resolve_additionalTextEdits().then_some(true)

retrigger_characters: None,

work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },

}),

code_action_provider: Some(config.caps().code_action_capabilities()),

document_range_formatting_provider: match config.rustfmt(None) {

},

document_on_type_formatting_provider: Some({

let mut chars = ide::Analysis::SUPPORTED_TRIGGER_CHARS.iter();

more_trigger_character: Some(chars.map(|c| c.to_string()).collect()),

}

}),

prepare_provider: Some(true),

work_done_progress_options: WorkDoneProgressOptions { work_done_progress: None },

})),

document_link_provider: None,

color_provider: None,

execute_command_provider: None,

workspace_folders: Some(WorkspaceFoldersServerCapabilities {

supported: Some(true),

}),

did_create: None,

will_create: None,

did_rename: None,

did_delete: None,

will_delete: None,

}),

}),

semantic_tokens_provider: Some(

SemanticTokensOptions {

legend: SemanticTokensLegend {

},

work_done_progress_options: Default::default(),

}

.into(),

),

moniker_provider: None,

},

experimental: Some(json!({

"externalDocs": true,

"hoverRange": true,

"ssr": true,

"workspaceSymbolScopeKindFiltering": true,

})),

}

}

})() == Some(true)

}

label_details_support: Some(self.completion_label_details_support()),

})

}

self.0

.text_document

.as_ref()

.and_then(|it| it.code_action.as_ref())

.and_then(|it| it.code_action_literal_support.as_ref())

// Advertise support for all built-in CodeActionKinds.

// Ideally we would base this off of the client capabilities

// but the client is supposed to fall back gracefully for unknown values.

code_action_kinds: Some(vec![

]),

resolve_provider: Some(true),

work_done_progress_options: Default::default(),

})

})

}

}

pub fn did_save_text_document_dynamic_registration(&self) -> bool {

caps.did_save == Some(true) && caps.dynamic_registration == Some(true)

}

}

pub fn diagnostics_refresh(&self) -> bool {

.unwrap_or_default()

}

use std::ops;

use lsp_types::{

};

use paths::Utf8PathBuf;

use rustc_hash::FxHashMap;

use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Debug)]

pub enum InternalTestingFetchConfigOption {

CheckWorkspace(bool),

}

type Params = InternalTestingFetchConfigParams;

// Option is solely to circumvent Default bound.

type Result = Option<InternalTestingFetchConfigResponse>;

}

#[derive(Deserialize, Serialize, Debug)]

pub text_document: Option<TextDocumentIdentifier>,

pub config: InternalTestingFetchConfigOption,

}

type Params = AnalyzerStatusParams;

type Result = String;

}

#[derive(Deserialize, Serialize, Debug)]

pub struct CrateInfoResult {

pub name: Option<String>,

pub version: Option<String>,

}

type Params = FetchDependencyListParams;

type Result = FetchDependencyListResult;

}

#[derive(Deserialize, Serialize, Debug)]

pub crates: Vec<CrateInfoResult>,

}

type Params = ();

type Result = String;

}

type Params = ();

type Result = ();

}

type Params = ();

type Result = ();

}

type Params = ViewSyntaxTreeParams;

type Result = String;

}

#[derive(Deserialize, Serialize, Debug)]

pub text_document: TextDocumentIdentifier,

}

type Params = lsp_types::TextDocumentPositionParams;

type Result = String;

}

type Params = lsp_types::TextDocumentPositionParams;

type Result = String;

}

type Params = lsp_types::TextDocumentPositionParams;

type Result = String;

}

type Params = lsp_types::TextDocumentIdentifier;

type Result = String;

}

#[derive(Deserialize, Serialize, Debug)]

pub full: bool,

}

type Params = ViewCrateGraphParams;

type Result = String;

}

#[derive(Deserialize, Serialize, Debug)]

pub text_document: TextDocumentIdentifier,

}

type Params = ViewItemTreeParams;

type Result = String;

}

#[derive(Deserialize, Serialize, Debug)]

pub scope_file: Option<Vec<TextDocumentIdentifier>>,

}

type Params = DiscoverTestParams;

type Result = DiscoverTestResults;

}

type Params = DiscoverTestResults;

}

#[derive(Deserialize, Serialize, Debug)]

pub exclude: Option<Vec<String>>,

}

type Params = RunTestParams;

type Result = ();

}

#[derive(Debug)]

type Params = ();

}

type Params = String;

}

type Params = ();

}

#[derive(Deserialize, Serialize, Debug)]

pub state: TestState,

}

type Params = ChangeTestStateParams;

}

type Params = ExpandMacroParams;

type Result = Option<ExpandedMacro>;

}

#[derive(Deserialize, Serialize, Debug)]

pub expansion: String,

}

type Params = lsp_types::TextDocumentPositionParams;

type Result = Option<RecursiveMemoryLayout>;

}

#[derive(Deserialize, Serialize, Debug)]

pub children_len: u64,

}

type Params = ();

}

type Params = RunFlycheckParams;

}

type Params = ();

}

type Params = ();

}

#[derive(Deserialize, Serialize, Debug)]

pub text_document: Option<TextDocumentIdentifier>,

}

type Params = MatchingBraceParams;

type Result = Vec<Position>;

}

#[derive(Deserialize, Serialize, Debug)]

pub positions: Vec<Position>,

}

type Params = lsp_types::TextDocumentPositionParams;

}

type Params = lsp_types::TextDocumentPositionParams;

}

type Params = JoinLinesParams;

type Result = Vec<lsp_types::TextEdit>;

}

#[derive(Deserialize, Serialize, Debug)]

pub ranges: Vec<Range>,

}

type Params = lsp_types::TextDocumentPositionParams;

type Result = Option<Vec<SnippetTextEdit>>;

}

type Params = RunnablesParams;

type Result = Vec<Runnable>;

}

#[derive(Serialize, Deserialize, Debug, Clone)]

pub args: Vec<String>,

}

type Params = lsp_types::TextDocumentPositionParams;

type Result = Vec<TestInfo>;

}

#[derive(Debug, Deserialize, Serialize)]

pub runnable: Runnable,

}

type Params = SsrParams;

type Result = lsp_types::WorkspaceEdit;

}

#[derive(Debug, Deserialize, Serialize)]

impl Notification for ServerStatusNotification {

type Params = ServerStatusParams;

}

#[derive(Deserialize, Serialize, PartialEq, Eq, Clone)]

impl Request for CodeActionRequest {

type Params = lsp_types::CodeActionParams;

type Result = Option<Vec<CodeAction>>;

}

pub enum CodeActionResolveRequest {}

impl Request for CodeActionResolveRequest {

type Params = CodeAction;

type Result = CodeAction;

}

#[derive(Debug, PartialEq, Clone, Default, Deserialize, Serialize)]

#[serde(rename_all = "camelCase")]

pub struct SnippetWorkspaceEdit {

#[serde(skip_serializing_if = "Option::is_none")]

#[serde(skip_serializing_if = "Option::is_none")]

pub document_changes: Option<Vec<SnippetDocumentChangeOperation>>,

#[serde(skip_serializing_if = "Option::is_none")]

#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]

#[serde(untagged, rename_all = "lowercase")]

pub enum SnippetDocumentChangeOperation {

Edit(SnippetTextDocumentEdit),

}

impl Request for HoverRequest {

type Params = HoverParams;

type Result = Option<Hover>;

}

#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]

pub tooltip: Option<String>,

}

type Params = lsp_types::TextDocumentPositionParams;

type Result = ExternalDocsResponse;

}

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]

#[serde(untagged)]

pub enum ExternalDocsResponse {

WithLocal(ExternalDocsPair),

}

#[derive(Debug, Default, PartialEq, Serialize, Deserialize, Clone)]

#[serde(rename_all = "camelCase")]

pub struct ExternalDocsPair {

}

type Params = OpenCargoTomlParams;

}

#[derive(Serialize, Deserialize, Debug)]

#[derive(Debug, Serialize, Deserialize)]

#[serde(rename_all = "camelCase")]

pub enum CodeLensResolveDataKind {

References(lsp_types::TextDocumentPositionParams),

}

type Params = MoveItemParams;

type Result = Vec<SnippetTextEdit>;

}

#[derive(Serialize, Deserialize, Debug)]

}

#[derive(Debug)]

type Params = WorkspaceSymbolParams;

type Result = Option<lsp_types::WorkspaceSymbolResponse>;

}

#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]

/// The document on type formatting request is sent from the client to

/// the server to format parts of the document during typing. This is

/// result has SnippetTextEdit in it instead of TextEdit.

#[derive(Debug)]

type Params = DocumentOnTypeFormattingParams;

type Result = Option<Vec<SnippetTextEdit>>;

}

#[derive(Debug, Serialize, Deserialize)]

pub commands: Vec<String>,

}

#[derive(Deserialize, Serialize, Debug)]

#[serde(rename_all = "camelCase")]

Unsupported,

}

type Params = EvaluatePredicateParams;

type Result = EvaluatePredicateResult;

}

#[derive(Deserialize, Serialize, Debug)]

#[serde(rename_all = "camelCase")]

pub position: Position,

}

type Params = GetFailedObligationsParams;

type Result = String;

}

#[cfg(test)]

//! Conversion lsp_types types to rust-analyzer specific ones.

use anyhow::format_err;

use ide::{Annotation, AnnotationKind, AssistKind, LineCol};

use ide_db::{FileId, FilePosition, FileRange, line_index::WideLineCol};

lsp_ext, try_default,

};

let path = url.to_file_path().map_err(|()| anyhow::format_err!("url is not a file"))?;

Ok(AbsPathBuf::try_from(Utf8PathBuf::from_path_buf(path).unwrap()).unwrap())

}

abs_path(url).map(vfs::VfsPath::from)

}

/// Returns `None` if the file was excluded.

pub(crate) fn file_id(

snap: &GlobalStateSnapshot,

) -> anyhow::Result<Option<FileId>> {

snap.url_to_file_id(url)

}

/// Returns `None` if the file was excluded.

pub(crate) fn file_position(

snap: &GlobalStateSnapshot,

) -> anyhow::Result<Option<FilePosition>> {

let file_id = try_default!(file_id(snap, &tdpp.text_document.uri)?);

let line_index = snap.file_line_index(file_id)?;

/// Returns `None` if the file was excluded.

pub(crate) fn file_range_uri(

snap: &GlobalStateSnapshot,

range: lsp_types::Range,

) -> anyhow::Result<Option<FileRange>> {

let file_id = try_default!(file_id(snap, document)?);

pub(crate) fn assist_kind(kind: lsp_types::CodeActionKind) -> Option<AssistKind> {

let assist_kind = match &kind {

_ => return None,

};

return Ok(None);

}

let pos @ FilePosition { file_id, .. } =

let line_index = snap.file_line_index(file_id)?;

Ok(Annotation {

if snap.url_file_version(&params.text_document.uri) != Some(data.version) {

return Ok(None);

}

let line_index = snap.file_line_index(file_id)?;

Ok(Annotation {

//! Semantic Tokens helpers

(

}

) => {

}

}

};

}

}

}

}

}

];

#[derive(Default)]

pub(crate) struct ModifierSet(pub(crate) u32);

}

}

self.0 |= 1 << idx;

}

}

id: String,

prev_line: u32,

prev_char: u32,

}

impl SemanticTokensBuilder {

pub(crate) fn new(id: String) -> Self {

}

/// Push a new token onto the builder

// A token cannot be multiline

let token_len = range.end.character - range.start.character;

delta_line: push_line,

delta_start: push_char,

length: token_len,

}

}

let offset = new.iter().zip(old.iter()).take_while(|&(n, p)| n == p).count();

let (_, old) = old.split_at(offset);

}

}

}

#[cfg(test)]

mod tests {

use super::*;

delta_line: t.0,

delta_start: t.1,

length: t.2,

SymbolKind::DeriveHelper => lsp_types::SymbolKind::DERIVE_HELPER,

SymbolKind::Module | SymbolKind::ToolModule => lsp_types::SymbolKind::MODULE,

SymbolKind::TypeAlias | SymbolKind::TypeParam | SymbolKind::SelfType => {

}

SymbolKind::Local

| SymbolKind::SelfParam

| SymbolKind::LifetimeParam

| SymbolKind::ValueParam

}

}

pub(crate) fn structure_node_kind(kind: StructureNodeKind) -> lsp_types::SymbolKind {

match kind {

StructureNodeKind::SymbolKind(symbol) => symbol_kind(symbol),

}

}

category: ReferenceCategory,

) -> Option<lsp_types::DocumentHighlightKind> {

if category.contains(ReferenceCategory::WRITE) {

}

if category.contains(ReferenceCategory::READ) {

}

None

}

pub(crate) fn diagnostic_severity(severity: Severity) -> lsp_types::DiagnosticSeverity {

match severity {

// unreachable

}

}

completion_item_kind: CompletionItemKind,

) -> lsp_types::CompletionItemKind {

match completion_item_kind {

CompletionItemKind::SymbolKind(symbol) => match symbol {

},

}

}

line_index: &LineIndex,

insert_replace_support: Option<lsp_types::Position>,

indel: Indel,

let text_edit = text_edit(line_index, indel);

match insert_replace_support {

Some(cursor_pos) => lsp_types::InsertReplaceEdit {

let annotation_id = annotation.filter(|_| client_supports_annotations).map(|it| it.to_string());

let text_edit = text_edit(line_index, indel);

let insert_text_format =

lsp_ext::SnippetTextEdit {

range: text_edit.range,

new_text: text_edit.new_text,

fields_to_resolve: &CompletionFieldsToResolve,

line_index: &LineIndex,

version: Option<i32>,

completion_trigger_character: Option<char>,

mut items: Vec<CompletionItem>,

) -> Vec<lsp_types::CompletionItem> {

fields_to_resolve,

line_index,

version,

max_relevance,

completion_trigger_character,

item,

Some(text_edit.unwrap())

};

let tags = if fields_to_resolve.resolve_tags {

something_to_resolve |= item.deprecated;

None

} else {

};

let command = if item.trigger_call_info && client_commands.trigger_parameter_hints {

if fields_to_resolve.resolve_command {

.not()

.then_some(additional_text_edits),

documentation,

deprecated: item.deprecated.then_some(item.deprecated),

tags,

command,

let params = call_info

.parameter_labels()

.map(|label| lsp_types::ParameterInformation {

documentation: None,

})

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

.chars()

.map(|c| c.len_utf16())

.sum::<usize>() as u32;

})

.map(|label_offsets| lsp_types::ParameterInformation {

documentation: None,

})

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

label.push_str(param);

let end = label.len() as u32;

params.push(lsp_types::ParameterInformation {

documentation: None,

});

}

})

});

let signature = lsp_types::SignatureInformation {

label,

padding_right: Some(inlay_hint.pad_right),

kind: match inlay_hint.kind {

InlayKind::Parameter | InlayKind::GenericParameter => {

}

_ => None,

},

text_edits,

something_to_resolve: &mut bool,

needs_resolve: bool,

mut label: InlayHintLabel,

let (label, tooltip) = match &*label.parts {

[InlayHintLabelPart { linked_location: None, .. }] => {

let InlayHintLabelPart { text, tooltip, .. } = label.parts.pop().unwrap();

}

});

let hint_tooltip = match tooltip {

Some(ide::InlayTooltip::Markdown(s)) => {

kind: lsp_types::MarkupKind::Markdown,

value: s,

}))

}

None => None,

};

}

_ => {

let parts = label

}

});

let tooltip = match tooltip {

Some(ide::InlayTooltip::Markdown(s)) => {

}

None => None,

};

})

})

.collect::<Cancellable<_>>()?;

}

};

Ok((label, tooltip))

if !non_standard_tokens {

ty = match standard_fallback_type(ty) {

None => continue,

};

mods.standard_fallback();

let token_index = semantic_tokens::type_index(ty);

let modifier_bitset = mods.0;

fn semantic_token_type_and_modifiers(

highlight: Highlight,

let mut mods = semantic_tokens::ModifierSet::default();

let ty = match highlight.tag {

HlTag::Symbol(symbol) => match symbol {

SymbolKind::CrateRoot => {

}

},

HlTag::Operator(op) => match op {

},

HlTag::Punctuation(punct) => match punct {

},

};

for modifier in highlight.mods.iter() {

let modifier = match modifier {

};

mods |= modifier;

}

}

}

snap.file_id_to_url(file_id)

}

/// This will only happen when processing windows paths.

///

match path.components().next() {

Some(Utf8Component::Prefix(prefix))

if matches!(prefix.kind(), Utf8Prefix::Disk(_) | Utf8Prefix::VerbatimDisk(_)) =>

// string in place.

let mut url: String = url.into();

url[driver_letter_range].make_ascii_lowercase();

}

pub(crate) fn optional_versioned_text_document_identifier(

snap: &GlobalStateSnapshot,

file_id: FileId,

) -> lsp_types::OptionalVersionedTextDocumentIdentifier {

}

pub(crate) fn location(

/// Prefer using `location_link`, if the client has the cap.

pub(crate) fn location_from_nav(

snap: &GlobalStateSnapshot,

) -> Cancellable<lsp_types::Location> {

let url = url(snap, nav.file_id);

let line_index = snap.file_line_index(nav.file_id)?;

fn location_info(

snap: &GlobalStateSnapshot,

target: NavigationTarget,

let line_index = snap.file_line_index(target.file_id)?;

let target_uri = url(snap, target.file_id);

snap: &GlobalStateSnapshot,

src: Option<FileRange>,

targets: Vec<NavigationTarget>,

if snap.config.location_link() {

Ok(links.into())

} else {

}

}

fn outside_workspace_annotation_id() -> String {

String::from("OutsideWorkspace")

}

match file_system_edit {

FileSystemEdit::CreateFile { dst, initial_contents } => {

let uri = snap.anchored_path(&dst);

uri: uri.clone(),

options: None,

annotation_id: None,

});

if !initial_contents.is_empty() {

let text_edit = lsp_ext::SnippetTextEdit {

range: lsp_types::Range::default(),

new_text: initial_contents,

annotation_id: None,

};

let edit_file =

{

rename_file.annotation_id = Some(outside_workspace_annotation_id())

}

}

FileSystemEdit::MoveDir { src, src_id, dst } => {

let old_uri = snap.anchored_path(&src);

{

rename_file.annotation_id = Some(outside_workspace_annotation_id())

}

}

}

Ok(ops)

lsp_types::WorkspaceEdit {

changes: None,

document_changes: snippet_workspace_edit.document_changes.map(|changes| {

}),

change_annotations: snippet_workspace_edit.change_annotations,

}

}

}

fn from(

lsp_ext::SnippetTextEdit { annotation_id, insert_text_format:_, new_text, range }: lsp_ext::SnippetTextEdit,

) -> Self {

match annotation_id {

}

}

}

) -> Cancellable<lsp_types::CallHierarchyItem> {

let name = target.name.to_string();

let detail = target.description.clone();

let (uri, range, selection_range) = location_info(snap, target)?;

Ok(lsp_types::CallHierarchyItem {

name,

pub(crate) fn code_action_kind(kind: AssistKind) -> lsp_types::CodeActionKind {

match kind {

}

}

let doc_pos = lsp_types::TextDocumentPositionParams::new(id, pos);

text_document_position_params: doc_pos,

work_done_progress_params: Default::default(),

partial_result_params: Default::default(),

pub(crate) fn show_references(

title: String,

position: lsp_types::Position,

locations: Vec<lsp_types::Location>,

) -> lsp_types::Command {

to_value(position).unwrap(),

to_value(locations).unwrap(),

]),

}

}

title: title.to_owned(),

command: "rust-analyzer.runSingle".into(),

arguments: Some(vec![to_value(runnable).unwrap()]),

}

}

title: "⚙\u{fe0e} Debug".into(),

command: "rust-analyzer.debugSingle".into(),

arguments: Some(vec![to_value(runnable).unwrap()]),

}

}

command: "rust-analyzer.interpretFunction".into(),

// FIXME: use the `_runnable` here.

arguments: Some(vec![]),

}

}

title: nav.name.to_string(),

command: "rust-analyzer.gotoLocation".into(),

arguments: Some(vec![value]),

})

}

title: "triggerParameterHints".into(),

command: "rust-analyzer.triggerParameterHints".into(),

arguments: None,

}

}

title: "rename".into(),

command: "rust-analyzer.rename".into(),

arguments: None,

}

}

}

)

}

#[test]

#[cfg(target_os = "windows")]

fn test_lowercase_drive_letter() {

//! Utilities for LSP-related boilerplate code.

use lsp_server::Notification;

use triomphe::Arc;

use crate::{

LspError { code: lsp_server::ErrorCode::InvalidParams as i32, message }

}

}

#[derive(Debug, Eq, PartialEq)]

impl GlobalState {

pub(crate) fn show_message(

&mut self,

message: String,

show_open_log_button: bool,

) {

lsp_types::ShowMessageRequestParams {

message,

actions: Some(vec![lsp_types::MessageActionItem {

title: "Open server logs".to_owned(),

}]),

},

|this, resp| {

let lsp_server::Response { error: None, result: Some(result), .. } = resp

) {

}

},

),

),

}

}

Some(additional_info) => {

tracing::error!("{message}:\n{additional_info}");

self.show_message(

message,

tracing::enabled!(tracing::Level::ERROR),

);

}

None => {

tracing::error!("{message}");

);

}

}

cancel_token.unwrap_or_else(|| format!("rustAnalyzer/{title}")),

);

tracing::debug!(?token, ?state, "report_progress {message:?}");

Progress::Begin => {

lsp_types::WorkDoneProgressCreateParams { token: token.clone() },

|_, _| (),

);

}

Progress::Report => {

}

Progress::End => {

}

}

}

) -> String {

// If at least one of the changes is a full document change, use the last

// of them as the starting point and ignore all previous changes.

return text;

}

// remember the last valid line in the index and only rebuild it if needed.

// The VFS will normalize the end of lines to `\n`.

let mut index_valid = !0u32;

}

}

text

) -> bool {

let mut edit_ranges = Vec::new();

match completion.text_edit.as_ref() {

edit_ranges.push(edit.range);

}

let replace = edit.replace;

let insert = edit.insert;

if replace.start != insert.start

#[cfg(test)]

mod tests {

use ide_db::line_index::WideEncoding;

use super::*;

fn test_apply_document_changes() {

macro_rules! c {

[$($sl:expr, $sc:expr; $el:expr, $ec:expr => $text:expr),+] => {

start: Position { line: $sl, character: $sc },

end: Position { line: $el, character: $ec },

text: String::from($text),

};

}

let text = apply_document_changes(

encoding,

&text,

);

assert_eq!(text, "the");

let text = apply_document_changes(encoding, &text, c![0, 3; 0, 3 => " quick"]);

#[test]

fn empty_completion_disjoint_tests() {

let disjoint_edit_1 = lsp_types::TextEdit::new(

Range::new(Position::new(2, 2), Position::new(3, 3)),

"new_text".to_owned(),

);

assert!(

!all_edits_are_disjoint(&completion_with_joint_edits, &[]),

"Completion with disjoint edits fails the validation even with empty extra edits"

);

completion_with_joint_edits.text_edit =

completion_with_joint_edits.additional_text_edits = Some(vec![joint_edit.clone()]);

assert!(

!all_edits_are_disjoint(&completion_with_joint_edits, &[]),

);

completion_with_joint_edits.text_edit =

new_text: "new_text".to_owned(),

insert: disjoint_edit.range,

replace: disjoint_edit_2.range,

"new_text".to_owned(),

);

assert!(

all_edits_are_disjoint(&completion_with_disjoint_edits, &[]),

use crossbeam_channel::{Receiver, never, select};

use ide_db::base_db::{SourceDatabase, VfsPath};

use lsp_server::{Connection, Notification, Request};

use stdx::thread::ThreadIntent;

use tracing::{Level, error, span};

use vfs::{AbsPathBuf, FileId, loader::LoadingProgress};

#[derive(Debug)]

pub(crate) enum DeferredTask {

CheckProcMacroSources(Vec<FileId>),

}

match self {

Event::Lsp(lsp_server::Message::Notification(not))

{

return debug_non_verbose(not, f);

}

if matches!(

&event,

Event::Lsp(lsp_server::Message::Notification(Notification { method, .. }))

) {

return Ok(());

}

}

fn register_did_save_capability(&mut self, additional_patterns: impl Iterator<Item = String>) {

});

let mut selectors = vec![

];

selectors.extend(additional_filters);

let save_registration_options = lsp_types::TextDocumentSaveRegistrationOptions {

text_document_registration_options: lsp_types::TextDocumentRegistrationOptions {

document_selector: Some(selectors),

},

method: "textDocument/didSave".to_owned(),

register_options: Some(serde_json::to_value(save_registration_options).unwrap()),

};

lsp_types::RegistrationParams { registrations: vec![registration] },

|_, _| (),

);

self.handle_flycheck_msg(message, &mut cargo_finished);

}

if cargo_finished {

}

}

Event::TestResult(message) => {

// Refresh semantic tokens if the client supports it.

if self.config.semantic_tokens_refresh() {

self.semantic_tokens_cache.lock().clear();

}

// Refresh code lens if the client supports it.

if self.config.code_lens_refresh() {

}

// Refresh inlay hints if the client supports it.

if self.config.inlay_hints_refresh() {

}

if self.config.diagnostics_refresh() {

}

}

|| self.fetch_workspace_error().is_err());

self.show_message(

match health {

},

message.clone(),

open_log_button,

self.discover_handles.push(handle)

}

Err(e) => self.show_message(

format!("Failed to spawn project discovery command: {e:#}"),

false,

),

}

Task::BuildDepsHaveChanged => self.build_deps_changed = true,

Task::DiscoverTest(tests) => {

}

}

cancellation_time

// The notification requires the namespace form (with underscores) of the target

let test_id = format!("{}::{name}", message.target.target.replace('-', "_"));

lsp_ext::ChangeTestStateParams { test_id, state },

);

}

CargoTestOutput::Finished => {

self.test_run_remaining_jobs = self.test_run_remaining_jobs.saturating_sub(1);

if self.test_run_remaining_jobs == 0 {

self.test_run_session = None;

}

}

CargoTestOutput::Custom { text } => {

}

}

}

/// Handles a request.

fn on_request(&mut self, req: Request) {

let mut dispatcher = RequestDispatcher { req: Some(req), global_state: self };

s.shutdown_requested = true;

s.proc_macro_clients =

std::iter::repeat_with(|| None).take(s.proc_macro_clients.len()).collect();

}

use crate::handlers::request as handlers;

const RETRY: bool = true;

const NO_RETRY: bool = false;

dispatcher

// Request handlers that must run on the main thread

// because they mutate GlobalState:

// Request handlers which are related to the user typing

// are run on the main thread to reduce latency:

// Formatting should be done immediately as the editor might wait on it, but we can't

// put it on the main thread as we do not want the main thread to block on rustfmt.

// So we have an extra thread just for formatting requests to make sure it gets handled

// as fast as possible.

// We can’t run latency-sensitive request handlers which do semantic

// analysis on the main thread because that would block other

// requests. Instead, we run these request handlers on higher priority

// threads in the threadpool.

// FIXME: Retrying can make the result of this stale?

// FIXME: Retrying can make the result of this stale

// FIXME: Some of these NO_RETRY could be retries if the file they are interested didn't change.

// All other request handlers

code: lsp_server::ErrorCode::ServerCancelled as i32,

message: "server cancelled the request".to_owned(),

data: serde_json::to_value(lsp_types::DiagnosticServerCancellationData {

retrigger_request: true

}).ok(),

})

// All other request handlers (lsp extension)

.on::<NO_RETRY, lsp_ext::CodeActionRequest>(handlers::handle_code_action)

.on_identity::<RETRY, lsp_ext::CodeActionResolveRequest, _>(handlers::handle_code_action_resolve)

.on::<NO_RETRY, lsp_ext::HoverRequest>(handlers::handle_hover)

//

.finish();

}

let _p =

span!(Level::INFO, "GlobalState::on_notification", not.method = ?not.method).entered();

use crate::handlers::notification as handlers;

NotificationDispatcher { not: Some(not), global_state: self }

handlers::handle_work_done_progress_cancel,

)

handlers::handle_did_change_configuration,

)

handlers::handle_did_change_workspace_folders,

)

.finish();

}

}

// FIXME: can we abort the build scripts here if they are already running?

self.workspaces = Arc::new(workspaces);

self.check_workspaces_msrv().for_each(|message| {

);

});

})

})

.map(|(base, pat)| lsp_types::FileSystemWatcher {

lsp_types::RelativePattern {

),

pattern: pat.to_owned(),

},

})

})

.map(|glob_pattern| lsp_types::FileSystemWatcher {

kind: None,

})

.collect()

continue;

};

watchers.push(lsp_types::FileSystemWatcher {

build.build_file.to_string(),

),

kind: None,

.chain(self.workspaces.iter().map(|ws| ws.manifest().map(ManifestPath::as_ref)))

.flatten()

.map(|glob_pattern| lsp_types::FileSystemWatcher {

kind: None,

}),

);

method: "workspace/didChangeWatchedFiles".to_owned(),

register_options: Some(serde_json::to_value(registration_options).unwrap()),

};

lsp_types::RegistrationParams { registrations: vec![registration] },

|_, _| (),

);

mod support;

mod testdir;

use ide_db::FxHashMap;

use lsp_types::{

};

use serde_json::json;

use stdx::format_to_acc;

.server()

.wait_until_workspace_is_loaded();

server.doc_id("src/lib.rs"),

Position::new(0, 23),

),

let hint = hints.pop().unwrap();

assert!(hint.data.is_some());

assert!(

);

let res = server.send_request::<InlayHintResolveRequest>(hint);

let hint = serde_json::from_value::<InlayHint>(res).unwrap();

assert!(hint.data.is_none());

assert!(

);

}

.server()

.wait_until_workspace_is_loaded();

server.doc_id("src/lib.rs"),

Position::new(5, 18),

),

});

assert!(res.to_string().contains("SpecialHashMap"), "{}", res.to_string());

server.doc_id("src/lib.rs"),

Position::new(6, 18),

),

std::thread::sleep(std::time::Duration::from_secs(3));

server.doc_id("src/lib.rs"),

Position::new(5, 18),

),

});

assert!(!res.to_string().contains("SpecialHashMap"));

server.doc_id("src/lib.rs"),

Position::new(6, 18),

),

.server()

.wait_until_workspace_is_loaded();

RunnablesParams { text_document: server.doc_id("foo/tests/spam.rs"), position: None },

json!([

{

.wait_until_workspace_is_loaded();

for runnable in ["consumer", "dependency", "devdependency"] {

RunnablesParams {

text_document: server.doc_id(&format!("{runnable}/src/lib.rs")),

position: None,

.server()

.wait_until_workspace_is_loaded();

RunnablesParams { text_document: server.doc_id("foo/mainpkg/src/main.rs"), position: None },

json!([

"{...}",

]),

);

RunnablesParams { text_document: server.doc_id("foo/otherpkg/src/lib.rs"), position: None },

json!([

"{...}",

)

.wait_until_workspace_is_loaded();

DocumentFormattingParams {

text_document: server.doc_id("src/lib.rs"),

options: FormattingOptions {

insert_final_newline: None,

trim_final_newlines: None,

trim_trailing_whitespace: None,

},

work_done_progress_params: WorkDoneProgressParams::default(),

},

)

.wait_until_workspace_is_loaded();

DocumentFormattingParams {

text_document: server.doc_id("src/lib.rs"),

options: FormattingOptions {

tab_size: 4,

insert_spaces: false,

insert_final_newline: None,

trim_final_newlines: None,

trim_trailing_whitespace: None,

)

.wait_until_workspace_is_loaded();

DocumentFormattingParams {

text_document: server.doc_id("src/lib.rs"),

options: FormattingOptions {

insert_final_newline: None,

trim_final_newlines: None,

trim_trailing_whitespace: None,

},

work_done_progress_params: WorkDoneProgressParams::default(),

},

.server()

.wait_until_workspace_is_loaded();

DocumentRangeFormattingParams {

range: Range {

end: Position { line: 1, character: 0 },

insert_final_newline: None,

trim_final_newlines: None,

trim_trailing_whitespace: None,

},

work_done_progress_params: WorkDoneProgressParams::default(),

},

.wait_until_workspace_is_loaded();

for i in 0..10 {

text_document: TextDocumentItem {

uri: server.doc_id(&format!("src/m{i}.rs")).uri,

version: 0,

text: "/// Docs\nfn foo() {}".to_owned(),

},

});

}

let start = Instant::now();

TextDocumentPositionParams {

text_document: server.doc_id("src/m0.rs"),

position: Position { line: 0, character: 5 },

.server()

.wait_until_workspace_is_loaded();

TextDocumentPositionParams {

text_document: server.doc_id("src/main.rs"),

position: Position { line: 0, character: 8 },

});

assert!(res.to_string().contains("&str"));

text_document_position_params: TextDocumentPositionParams::new(

server.doc_id("src/main.rs"),

Position::new(28, 9),

}]),

);

text_document_position_params: TextDocumentPositionParams::new(

server.doc_id("src/main.rs"),

Position::new(29, 9),

let server =

Project::with_fixture(code).tmp_dir(tmp_dir).server().wait_until_workspace_is_loaded();

RenameFilesParams {

files: vec![FileRename {

old_uri: base_path.join("src/old_file.rs").to_str().unwrap().to_owned(),

}),

);

RenameFilesParams {

files: vec![FileRename {

old_uri: base_path.join("src/from_mod/mod.rs").to_str().unwrap().to_owned(),

json!(null),

);

RenameFilesParams {

files: vec![FileRename {

old_uri: base_path.join("src/to_mod/foo.rs").to_str().unwrap().to_owned(),

json!(null),

);

RenameFilesParams {

files: vec![FileRename {

old_uri: base_path.join("src/old_folder").to_str().unwrap().to_owned(),

.server()

.wait_until_workspace_is_loaded();

rust_analyzer::lsp::ext::EvaluatePredicateParams {

text: "T: Trait".to_owned(),

text_document: server.doc_id("src/lib.rs"),

.server()

.wait_until_workspace_is_loaded();

rust_analyzer::lsp::ext::GetFailedObligationsParams {

text_document: server.doc_id("src/lib.rs"),

position: Position::new(4, 19),

use crate::support::{Project, Server};

use crate::testdir::TestDir;

use lsp_types::{

VersionedTextDocumentIdentifier,

};

use paths::Utf8PathBuf;

use rust_analyzer::config::Config;

use rust_analyzer::lsp::ext::{

};

use serde_json::json;

use test_utils::skip_slow_tests;

struct RatomlTest {

server: Server,

tmp_path: Utf8PathBuf,

}

case

}

let mut lines = fixture.trim().split('\n');

let mut path =

path = path.join(piece);

}

format!("file://{}", path.into_string().replace("C:\\", "/c:/").replace('\\', "/"))

.as_str(),

)

}

fn create(&mut self, fixture_path: &str, text: String) {

text_document: TextDocumentItem {

version: 0,

text: String::new(),

},

});

}

fn delete(&mut self, file_idx: usize) {

text_document: TextDocumentItem {

uri: self.urls[file_idx].clone(),

version: 0,

text: "".to_owned(),

},

});

// See if deleting ratoml file will make the config of interest to return to its default value.

text_document: TextDocumentIdentifier { uri: self.urls[file_idx].clone() },

text: Some("".to_owned()),

});

}

fn edit(&mut self, file_idx: usize, text: String) {

text_document: TextDocumentItem {

uri: self.urls[file_idx].clone(),

version: 0,

text: String::new(),

},

});

},

}

fn query(

source_file_idx: usize,

expected: InternalTestingFetchConfigResponse,

) {

InternalTestingFetchConfigParams {

text_document: Some(TextDocumentIdentifier {

uri: self.urls[source_file_idx].clone(),

use itertools::Itertools;

use lsp_server::{Connection, Message, Notification, Request};

use lsp_types::{

};

use parking_lot::{Mutex, MutexGuard};

use paths::{Utf8Path, Utf8PathBuf};

..Default::default()

}),

text_document: Some(lsp_types::TextDocumentClientCapabilities {

link_support: Some(true),

..Default::default()

}),

code_action: Some(lsp_types::CodeActionClientCapabilities {

code_action_literal_support: Some(

),

..Default::default()

}),

..Default::default()

}),

inlay_hint: Some(lsp_types::InlayHintClientCapabilities {

properties: vec![

"textEdits".to_owned(),

"tooltip".to_owned(),

pub(crate) fn doc_id(&self, rel_path: &str) -> TextDocumentIdentifier {

let path = self.dir.path().join(rel_path);

}

pub(crate) fn notification<N>(&self, params: N::Params)

where

N::Params: Serialize,

{

self.send_notification(r)

}

#[track_caller]

pub(crate) fn request<R>(&self, params: R::Params, expected_resp: Value)

where

R::Params: Serialize,

{

let actual = self.send_request::<R>(params);

#[track_caller]

pub(crate) fn send_request<R>(&self, params: R::Params) -> Value

where

R::Params: Serialize,

{

let id = self.req_id.get();

self.req_id.set(id.wrapping_add(1));

self.send_request_(r)

}

#[track_caller]

pub(crate) fn write_file_and_save(&self, path: &str, text: String) {

fs::write(self.dir.path().join(path), &text).unwrap();

lsp_types::DidSaveTextDocumentParams {

text_document: self.doc_id(path),

text: Some(text),

impl Drop for Server {

fn drop(&mut self) {

}

}

<!---

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:

For this reason, we ask that `initializationOptions` contains the configuration, as if the server did make a `"workspace/configuration"` request.

If a language client does not know about `rust-analyzer`'s configuration options it can get sensible defaults by doing any of the following:

## Snippet `TextEdit`

**Response:** `Location | Location[] | LocationLink[] | null`

### Example

```rust

Triggers the flycheck processes.

**Method:** `rust-analyzer/clearFlycheck`

**Notification:**

```

Such actions on the client side are appended to a hover bottom as command links:

```

+-----------------------------+

| Hover content |

**Response:** `Location | null`

### Example

```rust

position: Range | Position;

}

```

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.

### Example

Extends the existing `workspace/symbol` request with ability to filter symbols by broad scope and kind of symbol.

If this capability is set, `workspace/symbol` parameter gains two new optional fields:

```typescript

interface WorkspaceSymbolParams {

/**

This extensions allows the client to communicate this info.

```typescript

export interface ClientCommandOptions {

/**

```

**Response:**

```typescript

export interface FetchDependencyListResult {

crates: {

}[];

}

```

Returns all crates from this workspace, so it can be used create a viewTree to help navigate the dependency tree.

## View Recursive Memory Layout

Generic Types do not give anything because they are incomplete. Fully specified generic types do not give anything if they are selected directly but do work when a child of other types [this is consistent with other behavior](https://github.com/rust-lang/rust-analyzer/issues/15010).

[package]

name = "lsp-server"

description = "Generic LSP server scaffold."

license = "MIT OR Apache-2.0"

repository = "https://github.com/rust-lang/rust-analyzer/tree/master/lib/lsp-server"

[dev-dependencies]

lsp-types = { git = "https://git.bendn.org/helix", package = "helix-lsp-types" }

ctrlc = "3.4.7"

anyhow.workspace = true

rustc-hash.workspace = true

use std::{error::Error, io::Write};

use rustc_hash::FxHashMap; // fast hash map

use std::process::Stdio;

use toolchain::command; // clippy-approved wrapper

#[allow(clippy::print_stderr, clippy::disallowed_types, clippy::disallowed_methods)]

use anyhow::{Context, Result, anyhow, bail};

use lsp_server::{Connection, Message, Request as ServerRequest, RequestId, Response};

// =====================================================================

// main

// advertised capabilities

let caps = ServerCapabilities {

completion_provider: Some(CompletionOptions::default()),

..Default::default()

};

let init_value = serde_json::json!({

params: serde_json::Value,

) -> std::result::Result<(), Box<dyn Error + Sync + Send>> {

let _init: InitializeParams = serde_json::from_value(params)?;

for msg in &connection.receiver {

match msg {

fn handle_notification(

conn: &Connection,

note: &lsp_server::Notification,

) -> Result<()> {

let p: DidOpenTextDocumentParams = serde_json::from_value(note.params.clone())?;

let uri = p.text_document.uri;

docs.insert(uri.clone(), p.text_document.text);

publish_dummy_diag(conn, &uri)?;

}

let p: DidChangeTextDocumentParams = serde_json::from_value(note.params.clone())?;

if let Some(change) = p.content_changes.into_iter().next() {

publish_dummy_diag(conn, &uri)?;

}

}

fn handle_request(

conn: &Connection,

req: &ServerRequest,

) -> Result<()> {

}

let item = CompletionItem {

label: "HelloFromLSP".into(),

detail: Some("dummy completion".into()),

..Default::default()

};

}

HoverRequest::METHOD => {

let hover = Hover {

"Hello from *minimal_lsp*".into(),

)),

range: None,

};

send_ok(conn, req.id.clone(), &hover)?;

}

let p: DocumentFormattingParams = serde_json::from_value(req.params.clone())?;

let uri = p.text_document.uri;

let text = docs

// =====================================================================

// diagnostics

// =====================================================================

let diag = Diagnostic {

range: Range::new(Position::new(0, 0), Position::new(0, 1)),

code: None,

code_description: None,

source: Some("minimal_lsp".into()),

let params =

PublishDiagnosticsParams { uri: uri.clone(), diagnostics: vec![diag], version: None };

conn.sender.send(Message::Notification(lsp_server::Notification::new(

params,

)))?;

Ok(())

#[cfg(test)]

mod tests {

use crossbeam_channel::unbounded;

use serde_json::to_value;

use crate::{Connection, Message, ProtocolError, RequestId};

#[test]

fn not_exit_notification() {

let notification = crate::Notification {

params: to_value(InitializedParams {}).unwrap(),

};

let req_id = RequestId::from(234);

let request = crate::Request {

id: req_id.clone(),

params: params_as_value.clone(),

};

#[test]

fn exit_notification() {

let notification_msg = Message::from(notification);

initialize_start_test(TestCase {