From 61f3a438d3a729a6be941bca1ff4c6a97a33f221 Mon Sep 17 00:00:00 2001 From: "Jeremy A. Kolb" Date: Mon, 15 Oct 2018 17:44:23 -0400 Subject: Cargo Format Run `cargo fmt` and ignore generated files --- crates/ra_lsp_server/src/caps.rs | 16 +- crates/ra_lsp_server/src/conv.rs | 66 ++++--- crates/ra_lsp_server/src/lib.rs | 21 +-- crates/ra_lsp_server/src/main.rs | 6 +- crates/ra_lsp_server/src/main_loop/handlers.rs | 206 ++++++++++++--------- crates/ra_lsp_server/src/main_loop/mod.rs | 161 ++++++++-------- .../ra_lsp_server/src/main_loop/subscriptions.rs | 6 +- crates/ra_lsp_server/src/path_map.rs | 28 +-- crates/ra_lsp_server/src/project_model.rs | 32 ++-- crates/ra_lsp_server/src/req.rs | 27 +-- crates/ra_lsp_server/src/server_world.rs | 76 ++++---- crates/ra_lsp_server/src/thread_watcher.rs | 19 +- crates/ra_lsp_server/src/vfs.rs | 12 +- 13 files changed, 350 insertions(+), 326 deletions(-) (limited to 'crates/ra_lsp_server/src') diff --git a/crates/ra_lsp_server/src/caps.rs b/crates/ra_lsp_server/src/caps.rs index 5598ec75f..1dd495791 100644 --- a/crates/ra_lsp_server/src/caps.rs +++ b/crates/ra_lsp_server/src/caps.rs @@ -1,14 +1,8 @@ use languageserver_types::{ - ServerCapabilities, - CodeActionProviderCapability, - FoldingRangeProviderCapability, - TextDocumentSyncCapability, + CodeActionProviderCapability, CompletionOptions, DocumentOnTypeFormattingOptions, + ExecuteCommandOptions, FoldingRangeProviderCapability, ServerCapabilities, + SignatureHelpOptions, TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions, - TextDocumentSyncKind, - ExecuteCommandOptions, - CompletionOptions, - SignatureHelpOptions, - DocumentOnTypeFormattingOptions, }; pub fn server_capabilities() -> ServerCapabilities { @@ -20,7 +14,7 @@ pub fn server_capabilities() -> ServerCapabilities { will_save: None, will_save_wait_until: None, save: None, - } + }, )), hover_provider: None, completion_provider: Some(CompletionOptions { @@ -28,7 +22,7 @@ pub fn server_capabilities() -> ServerCapabilities { trigger_characters: None, }), signature_help_provider: Some(SignatureHelpOptions { - trigger_characters: Some(vec!["(".to_string(), ",".to_string()]) + trigger_characters: Some(vec!["(".to_string(), ",".to_string()]), }), definition_provider: Some(true), type_definition_provider: None, diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs index a75b160c5..8325e8c1e 100644 --- a/crates/ra_lsp_server/src/conv.rs +++ b/crates/ra_lsp_server/src/conv.rs @@ -1,17 +1,12 @@ use languageserver_types::{ - Range, SymbolKind, Position, TextEdit, Location, Url, - TextDocumentIdentifier, VersionedTextDocumentIdentifier, TextDocumentItem, - TextDocumentPositionParams, TextDocumentEdit, -}; -use ra_editor::{LineIndex, LineCol, Edit, AtomEdit}; -use ra_syntax::{SyntaxKind, TextUnit, TextRange}; -use ra_analysis::{FileId, SourceChange, SourceFileEdit, FileSystemEdit}; - -use crate::{ - Result, - server_world::ServerWorld, - req, + Location, Position, Range, SymbolKind, TextDocumentEdit, TextDocumentIdentifier, + TextDocumentItem, TextDocumentPositionParams, TextEdit, Url, VersionedTextDocumentIdentifier, }; +use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileEdit}; +use ra_editor::{AtomEdit, Edit, LineCol, LineIndex}; +use ra_syntax::{SyntaxKind, TextRange, TextUnit}; + +use crate::{req, server_world::ServerWorld, Result}; pub trait Conv { type Output; @@ -190,8 +185,12 @@ impl TryConvWith for SourceChange { None => None, Some(pos) => { let line_index = world.analysis().file_line_index(pos.file_id); - let edits = self.source_file_edits.iter().find(|it| it.file_id == pos.file_id) - .map(|it| it.edits.as_slice()).unwrap_or(&[]); + let edits = self + .source_file_edits + .iter() + .find(|it| it.file_id == pos.file_id) + .map(|it| it.edits.as_slice()) + .unwrap_or(&[]); let line_col = translate_offset_with_edit(&*line_index, pos.offset, edits); let position = Position::new(line_col.line as u64, u32::from(line_col.col) as u64); Some(TextDocumentPositionParams { @@ -224,11 +223,11 @@ fn translate_offset_with_edit( let fallback = pre_edit_index.line_col(offset); let edit = match edits.first() { None => return fallback, - Some(edit) => edit + Some(edit) => edit, }; let end_offset = edit.delete.start() + TextUnit::of_str(&edit.insert); if !(edit.delete.start() <= offset && offset <= end_offset) { - return fallback + return fallback; } let rel_offset = offset - edit.delete.start(); let in_edit_line_col = LineIndex::new(&edit.insert).line_col(rel_offset); @@ -255,11 +254,11 @@ impl TryConvWith for SourceFileEdit { version: None, }; let line_index = world.analysis().file_line_index(self.file_id); - let edits = self.edits - .into_iter() - .map_conv_with(&line_index) - .collect(); - Ok(TextDocumentEdit { text_document, edits }) + let edits = self.edits.into_iter().map_conv_with(&line_index).collect(); + Ok(TextDocumentEdit { + text_document, + edits, + }) } } @@ -273,13 +272,13 @@ impl TryConvWith for FileSystemEdit { let path = &path.as_str()[3..]; // strip `../` b/c url is weird let uri = uri.join(path)?; req::FileSystemEdit::CreateFile { uri } - }, + } FileSystemEdit::MoveFile { file, path } => { let src = world.file_id_to_uri(file)?; let path = &path.as_str()[3..]; // strip `../` b/c url is weird let dst = src.join(path)?; req::FileSystemEdit::MoveFile { src, dst } - }, + } }; Ok(res) } @@ -291,12 +290,9 @@ pub fn to_location( world: &ServerWorld, line_index: &LineIndex, ) -> Result { - let url = file_id.try_conv_with(world)?; - let loc = Location::new( - url, - range.conv_with(line_index), - ); - Ok(loc) + let url = file_id.try_conv_with(world)?; + let loc = Location::new(url, range.conv_with(line_index)); + Ok(loc) } pub trait MapConvWith<'a>: Sized + 'a { @@ -309,8 +305,9 @@ pub trait MapConvWith<'a>: Sized + 'a { } impl<'a, I> MapConvWith<'a> for I - where I: Iterator + 'a, - I::Item: ConvWith +where + I: Iterator + 'a, + I::Item: ConvWith, { type Ctx = ::Ctx; type Output = ::Output; @@ -322,9 +319,9 @@ pub struct ConvWithIter<'a, I, Ctx: 'a> { } impl<'a, I, Ctx> Iterator for ConvWithIter<'a, I, Ctx> - where - I: Iterator, - I::Item: ConvWith, +where + I: Iterator, + I::Item: ConvWith, { type Item = ::Output; @@ -332,4 +329,3 @@ impl<'a, I, Ctx> Iterator for ConvWithIter<'a, I, Ctx> self.iter.next().map(|item| item.conv_with(self.ctx)) } } - diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs index 7224b1476..f1b17f282 100644 --- a/crates/ra_lsp_server/src/lib.rs +++ b/crates/ra_lsp_server/src/lib.rs @@ -2,39 +2,36 @@ extern crate failure; #[macro_use] extern crate serde_derive; +extern crate languageserver_types; extern crate serde; extern crate serde_json; -extern crate languageserver_types; #[macro_use] extern crate crossbeam_channel; extern crate rayon; #[macro_use] extern crate log; +extern crate cargo_metadata; extern crate drop_bomb; -extern crate url_serde; -extern crate walkdir; extern crate im; extern crate relative_path; -extern crate cargo_metadata; extern crate rustc_hash; +extern crate url_serde; +extern crate walkdir; extern crate gen_lsp_server; -extern crate ra_editor; extern crate ra_analysis; +extern crate ra_editor; extern crate ra_syntax; mod caps; -pub mod req; mod conv; mod main_loop; -mod vfs; mod path_map; -mod server_world; mod project_model; +pub mod req; +mod server_world; pub mod thread_watcher; +mod vfs; pub type Result = ::std::result::Result; -pub use crate::{ - main_loop::main_loop, - caps::server_capabilities, -}; +pub use crate::{caps::server_capabilities, main_loop::main_loop}; diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs index e5d1792b7..9f62347f1 100644 --- a/crates/ra_lsp_server/src/main.rs +++ b/crates/ra_lsp_server/src/main.rs @@ -6,7 +6,7 @@ extern crate flexi_logger; extern crate gen_lsp_server; extern crate ra_lsp_server; -use flexi_logger::{Logger, Duplicate}; +use flexi_logger::{Duplicate, Logger}; use gen_lsp_server::{run_server, stdio_transport}; use ra_lsp_server::Result; @@ -38,7 +38,8 @@ fn main_inner() -> Result<()> { receiver, sender, |params, r, s| { - let root = params.root_uri + let root = params + .root_uri .and_then(|it| it.to_file_path().ok()) .unwrap_or(cwd); ra_lsp_server::main_loop(false, root, r, s) @@ -49,4 +50,3 @@ fn main_inner() -> Result<()> { info!("... IO is down"); Ok(()) } - diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs index 5acb39b60..c25b63852 100644 --- a/crates/ra_lsp_server/src/main_loop/handlers.rs +++ b/crates/ra_lsp_server/src/main_loop/handlers.rs @@ -1,23 +1,20 @@ use rustc_hash::FxHashMap; use languageserver_types::{ - Diagnostic, DiagnosticSeverity, DocumentSymbol, - CodeActionResponse, Command, TextDocumentIdentifier, - SymbolInformation, Position, Location, TextEdit, - CompletionItem, InsertTextFormat, CompletionItemKind, - FoldingRange, FoldingRangeParams, FoldingRangeKind + CodeActionResponse, Command, CompletionItem, CompletionItemKind, Diagnostic, + DiagnosticSeverity, DocumentSymbol, FoldingRange, FoldingRangeKind, FoldingRangeParams, + InsertTextFormat, Location, Position, SymbolInformation, TextDocumentIdentifier, TextEdit, }; +use ra_analysis::{FileId, FoldKind, JobToken, Query, RunnableKind}; +use ra_syntax::text_utils::contains_offset_nonstrict; use serde_json::to_value; -use ra_analysis::{Query, FileId, RunnableKind, JobToken, FoldKind}; -use ra_syntax::{ - text_utils::contains_offset_nonstrict -}; use crate::{ - req::{self, Decoration}, Result, - conv::{Conv, ConvWith, TryConvWith, MapConvWith, to_location}, - server_world::ServerWorld, + conv::{to_location, Conv, ConvWith, MapConvWith, TryConvWith}, project_model::TargetKind, + req::{self, Decoration}, + server_world::ServerWorld, + Result, }; pub fn handle_syntax_tree( @@ -38,7 +35,9 @@ pub fn handle_extend_selection( let file_id = params.text_document.try_conv_with(&world)?; let file = world.analysis().file_syntax(file_id); let line_index = world.analysis().file_line_index(file_id); - let selections = params.selections.into_iter() + let selections = params + .selections + .into_iter() .map_conv_with(&line_index) .map(|r| world.analysis().extend_selection(&file, r)) .map_conv_with(&line_index) @@ -54,11 +53,15 @@ pub fn handle_find_matching_brace( let file_id = params.text_document.try_conv_with(&world)?; let file = world.analysis().file_syntax(file_id); let line_index = world.analysis().file_line_index(file_id); - let res = params.offsets + let res = params + .offsets .into_iter() .map_conv_with(&line_index) .map(|offset| { - world.analysis().matching_brace(&file, offset).unwrap_or(offset) + world + .analysis() + .matching_brace(&file, offset) + .unwrap_or(offset) }) .map_conv_with(&line_index) .collect(); @@ -73,7 +76,9 @@ pub fn handle_join_lines( let file_id = params.text_document.try_conv_with(&world)?; let line_index = world.analysis().file_line_index(file_id); let range = params.range.conv_with(&line_index); - world.analysis().join_lines(file_id, range) + world + .analysis() + .join_lines(file_id, range) .try_conv_with(&world) } @@ -87,7 +92,7 @@ pub fn handle_on_enter( let offset = params.position.conv_with(&line_index); match world.analysis().on_enter(file_id, offset) { None => Ok(None), - Some(edit) => Ok(Some(edit.try_conv_with(&world)?)) + Some(edit) => Ok(Some(edit.try_conv_with(&world)?)), } } @@ -158,7 +163,9 @@ pub fn handle_workspace_symbol( let all_symbols = params.query.contains("#"); let libs = params.query.contains("*"); let query = { - let query: String = params.query.chars() + let query: String = params + .query + .chars() .filter(|&c| c != '#' && c != '*') .collect(); let mut q = Query::new(query); @@ -180,22 +187,23 @@ pub fn handle_workspace_symbol( return Ok(Some(res)); - fn exec_query(world: &ServerWorld, query: Query, token: &JobToken) -> Result> { + fn exec_query( + world: &ServerWorld, + query: Query, + token: &JobToken, + ) -> Result> { let mut res = Vec::new(); for (file_id, symbol) in world.analysis().symbol_search(query, token) { let line_index = world.analysis().file_line_index(file_id); let info = SymbolInformation { name: symbol.name.to_string(), kind: symbol.kind.conv(), - location: to_location( - file_id, symbol.node_range, - world, &line_index - )?, + location: to_location(file_id, symbol.node_range, world, &line_index)?, container_name: None, deprecated: None, }; res.push(info); - }; + } Ok(res) } } @@ -209,12 +217,12 @@ pub fn handle_goto_definition( let line_index = world.analysis().file_line_index(file_id); let offset = params.position.conv_with(&line_index); let mut res = Vec::new(); - for (file_id, symbol) in world.analysis().approximately_resolve_symbol(file_id, offset, &token) { + for (file_id, symbol) in world + .analysis() + .approximately_resolve_symbol(file_id, offset, &token) + { let line_index = world.analysis().file_line_index(file_id); - let location = to_location( - file_id, symbol.node_range, - &world, &line_index, - )?; + let location = to_location(file_id, symbol.node_range, &world, &line_index)?; res.push(location) } Ok(Some(req::GotoDefinitionResponse::Array(res))) @@ -229,10 +237,7 @@ pub fn handle_parent_module( let mut res = Vec::new(); for (file_id, symbol) in world.analysis().parent_module(file_id) { let line_index = world.analysis().file_line_index(file_id); - let location = to_location( - file_id, symbol.node_range, - &world, &line_index - )?; + let location = to_location(file_id, symbol.node_range, &world, &line_index)?; res.push(location); } Ok(res) @@ -259,21 +264,16 @@ pub fn handle_runnables( let r = req::Runnable { range: runnable.range.conv_with(&line_index), label: match &runnable.kind { - RunnableKind::Test { name } => - format!("test {}", name), - RunnableKind::Bin => - "run binary".to_string(), + RunnableKind::Test { name } => format!("test {}", name), + RunnableKind::Bin => "run binary".to_string(), }, bin: "cargo".to_string(), args, env: { let mut m = FxHashMap::default(); - m.insert( - "RUST_BACKTRACE".to_string(), - "short".to_string(), - ); + m.insert("RUST_BACKTRACE".to_string(), "short".to_string()); m - } + }, }; res.push(r); } @@ -283,10 +283,16 @@ pub fn handle_runnables( let spec = if let Some(&crate_id) = world.analysis().crate_for(file_id).first() { let file_id = world.analysis().crate_root(crate_id); let path = world.path_map.get_path(file_id); - world.workspaces.iter() + world + .workspaces + .iter() .filter_map(|ws| { let tgt = ws.target_by_root(path)?; - Some((tgt.package(ws).name(ws).clone(), tgt.name(ws).clone(), tgt.kind(ws))) + Some(( + tgt.package(ws).name(ws).clone(), + tgt.name(ws).clone(), + tgt.kind(ws), + )) }) .next() } else { @@ -294,22 +300,22 @@ pub fn handle_runnables( }; let mut res = Vec::new(); match kind { - RunnableKind::Test { name } => { - res.push("test".to_string()); - if let Some((pkg_name, tgt_name, tgt_kind)) = spec { - spec_args(pkg_name, tgt_name, tgt_kind, &mut res); - } - res.push("--".to_string()); - res.push(name.to_string()); - res.push("--nocapture".to_string()); + RunnableKind::Test { name } => { + res.push("test".to_string()); + if let Some((pkg_name, tgt_name, tgt_kind)) = spec { + spec_args(pkg_name, tgt_name, tgt_kind, &mut res); } - RunnableKind::Bin => { - res.push("run".to_string()); - if let Some((pkg_name, tgt_name, tgt_kind)) = spec { - spec_args(pkg_name, tgt_name, tgt_kind, &mut res); - } + res.push("--".to_string()); + res.push(name.to_string()); + res.push("--nocapture".to_string()); + } + RunnableKind::Bin => { + res.push("run".to_string()); + if let Some((pkg_name, tgt_name, tgt_kind)) = spec { + spec_args(pkg_name, tgt_name, tgt_kind, &mut res); } } + } res } @@ -362,12 +368,13 @@ pub fn handle_completion( None => return Ok(None), Some(items) => items, }; - let items = items.into_iter() + let items = items + .into_iter() .map(|item| { let mut res = CompletionItem { label: item.label, filter_text: item.lookup, - .. Default::default() + ..Default::default() }; if let Some(snip) = item.snippet { res.insert_text = Some(snip); @@ -389,24 +396,27 @@ pub fn handle_folding_range( let file_id = params.text_document.try_conv_with(&world)?; let line_index = world.analysis().file_line_index(file_id); - let res = Some(world.analysis() - .folding_ranges(file_id) - .into_iter() - .map(|fold| { - let kind = match fold.kind { - FoldKind::Comment => FoldingRangeKind::Comment, - FoldKind::Imports => FoldingRangeKind::Imports - }; - let range = fold.range.conv_with(&line_index); - FoldingRange { - start_line: range.start.line, - start_character: Some(range.start.character), - end_line: range.end.line, - end_character: Some(range.start.character), - kind: Some(kind) - } - }) - .collect()); + let res = Some( + world + .analysis() + .folding_ranges(file_id) + .into_iter() + .map(|fold| { + let kind = match fold.kind { + FoldKind::Comment => FoldingRangeKind::Comment, + FoldKind::Imports => FoldingRangeKind::Imports, + }; + let range = fold.range.conv_with(&line_index); + FoldingRange { + start_line: range.start.line, + start_character: Some(range.start.character), + end_line: range.end.line, + end_character: Some(range.start.character), + kind: Some(kind), + } + }) + .collect(), + ); Ok(res) } @@ -422,25 +432,28 @@ pub fn handle_signature_help( let line_index = world.analysis().file_line_index(file_id); let offset = params.position.conv_with(&line_index); - if let Some((descriptor, active_param)) = world.analysis().resolve_callable(file_id, offset, &token) { - let parameters : Vec = - descriptor.params.iter().map(|param| - ParameterInformation { - label: param.clone(), - documentation: None - } - ).collect(); + if let Some((descriptor, active_param)) = + world.analysis().resolve_callable(file_id, offset, &token) + { + let parameters: Vec = descriptor + .params + .iter() + .map(|param| ParameterInformation { + label: param.clone(), + documentation: None, + }) + .collect(); let sig_info = SignatureInformation { label: descriptor.label, documentation: None, - parameters: Some(parameters) + parameters: Some(parameters), }; Ok(Some(req::SignatureHelp { signatures: vec![sig_info], active_signature: Some(0), - active_parameter: active_param.map(|a| a as u64) + active_parameter: active_param.map(|a| a as u64), })) } else { Ok(None) @@ -457,7 +470,10 @@ pub fn handle_code_action( let range = params.range.conv_with(&line_index); let assists = world.analysis().assists(file_id, range).into_iter(); - let fixes = world.analysis().diagnostics(file_id).into_iter() + let fixes = world + .analysis() + .diagnostics(file_id) + .into_iter() .filter_map(|d| Some((d.range, d.fix?))) .filter(|(range, _fix)| contains_offset_nonstrict(*range, range.start())) .map(|(_range, fix)| fix); @@ -483,7 +499,9 @@ pub fn publish_diagnostics( ) -> Result { let uri = world.file_id_to_uri(file_id)?; let line_index = world.analysis().file_line_index(file_id); - let diagnostics = world.analysis().diagnostics(file_id) + let diagnostics = world + .analysis() + .diagnostics(file_id) .into_iter() .map(|d| Diagnostic { range: d.range.conv_with(&line_index), @@ -492,7 +510,8 @@ pub fn publish_diagnostics( source: Some("rust-analyzer".to_string()), message: d.message, related_information: None, - }).collect(); + }) + .collect(); Ok(req::PublishDiagnosticsParams { uri, diagnostics }) } @@ -509,10 +528,13 @@ pub fn publish_decorations( fn highlight(world: &ServerWorld, file_id: FileId) -> Vec { let line_index = world.analysis().file_line_index(file_id); - world.analysis().highlight(file_id) + world + .analysis() + .highlight(file_id) .into_iter() .map(|h| Decoration { range: h.range.conv_with(&line_index), tag: h.tag, - }).collect() + }) + .collect() } diff --git a/crates/ra_lsp_server/src/main_loop/mod.rs b/crates/ra_lsp_server/src/main_loop/mod.rs index cf2477cb5..a11baf4aa 100644 --- a/crates/ra_lsp_server/src/main_loop/mod.rs +++ b/crates/ra_lsp_server/src/main_loop/mod.rs @@ -1,29 +1,26 @@ mod handlers; mod subscriptions; -use std::{ - path::PathBuf, -}; +use std::path::PathBuf; -use serde::{Serialize, de::DeserializeOwned}; -use crossbeam_channel::{unbounded, Sender, Receiver}; -use rayon::{self, ThreadPool}; -use languageserver_types::{NumberOrString}; -use ra_analysis::{FileId, JobHandle, JobToken, LibraryData}; +use crossbeam_channel::{unbounded, Receiver, Sender}; use gen_lsp_server::{ - RawRequest, RawNotification, RawMessage, RawResponse, ErrorCode, - handle_shutdown, + handle_shutdown, ErrorCode, RawMessage, RawNotification, RawRequest, RawResponse, }; +use languageserver_types::NumberOrString; +use ra_analysis::{FileId, JobHandle, JobToken, LibraryData}; +use rayon::{self, ThreadPool}; use rustc_hash::FxHashMap; +use serde::{de::DeserializeOwned, Serialize}; use crate::{ + main_loop::subscriptions::Subscriptions, + project_model::{workspace_loader, CargoWorkspace}, req, - Result, - vfs::{self, FileEvent}, - server_world::{ServerWorldState, ServerWorld}, - main_loop::subscriptions::{Subscriptions}, - project_model::{CargoWorkspace, workspace_loader}, + server_world::{ServerWorld, ServerWorldState}, thread_watcher::Worker, + vfs::{self, FileEvent}, + Result, }; #[derive(Debug)] @@ -147,56 +144,50 @@ fn main_loop_inner( } state_changed = true; } - Event::Ws(ws) => { - match ws { - Ok(ws) => { - let workspaces = vec![ws]; - feedback(internal_mode, "workspace loaded", msg_sender); - for ws in workspaces.iter() { - for pkg in ws.packages().filter(|pkg| !pkg.is_member(ws)) { - debug!("sending root, {}", pkg.root(ws).to_path_buf().display()); - fs_worker.send(pkg.root(ws).to_path_buf()); - } + Event::Ws(ws) => match ws { + Ok(ws) => { + let workspaces = vec![ws]; + feedback(internal_mode, "workspace loaded", msg_sender); + for ws in workspaces.iter() { + for pkg in ws.packages().filter(|pkg| !pkg.is_member(ws)) { + debug!("sending root, {}", pkg.root(ws).to_path_buf().display()); + fs_worker.send(pkg.root(ws).to_path_buf()); } - state.set_workspaces(workspaces); - state_changed = true; } - Err(e) => warn!("loading workspace failed: {}", e), + state.set_workspaces(workspaces); + state_changed = true; } - } + Err(e) => warn!("loading workspace failed: {}", e), + }, Event::Lib(lib) => { feedback(internal_mode, "library loaded", msg_sender); state.add_lib(lib); } - Event::Msg(msg) => { - match msg { - RawMessage::Request(req) => { - let req = match handle_shutdown(req, msg_sender) { - Some(req) => req, - None => return Ok(()), - }; - match on_request(state, pending_requests, pool, &task_sender, req)? { - None => (), - Some(req) => { - error!("unknown request: {:?}", req); - let resp = RawResponse::err( - req.id, - ErrorCode::MethodNotFound as i32, - "unknown request".to_string(), - ); - msg_sender.send(RawMessage::Response(resp)) - } + Event::Msg(msg) => match msg { + RawMessage::Request(req) => { + let req = match handle_shutdown(req, msg_sender) { + Some(req) => req, + None => return Ok(()), + }; + match on_request(state, pending_requests, pool, &task_sender, req)? { + None => (), + Some(req) => { + error!("unknown request: {:?}", req); + let resp = RawResponse::err( + req.id, + ErrorCode::MethodNotFound as i32, + "unknown request".to_string(), + ); + msg_sender.send(RawMessage::Response(resp)) } } - RawMessage::Notification(not) => { - on_notification(msg_sender, state, pending_requests, subs, not)?; - state_changed = true; - } - RawMessage::Response(resp) => { - error!("unexpected response: {:?}", resp) - } } - } + RawMessage::Notification(not) => { + on_notification(msg_sender, state, pending_requests, subs, not)?; + state_changed = true; + } + RawMessage::Response(resp) => error!("unexpected response: {:?}", resp), + }, }; if state_changed { @@ -222,8 +213,7 @@ fn on_task( } msg_sender.send(RawMessage::Response(response)) } - Task::Notify(n) => - msg_sender.send(RawMessage::Notification(n)), + Task::Notify(n) => msg_sender.send(RawMessage::Notification(n)), } } @@ -237,7 +227,9 @@ fn on_request( let mut pool_dispatcher = PoolDispatcher { req: Some(req), res: None, - pool, world, sender + pool, + world, + sender, }; let req = pool_dispatcher .on::(handlers::handle_syntax_tree)? @@ -262,7 +254,7 @@ fn on_request( let inserted = pending_requests.insert(id, handle).is_none(); assert!(inserted, "duplicate request: {}", id); Ok(None) - }, + } Err(req) => Ok(Some(req)), } } @@ -285,45 +277,53 @@ fn on_notification( if let Some(handle) = pending_requests.remove(&id) { handle.cancel(); } - return Ok(()) + return Ok(()); } Err(not) => not, }; let not = match not.cast::() { Ok(params) => { let uri = params.text_document.uri; - let path = uri.to_file_path() + let path = uri + .to_file_path() .map_err(|()| format_err!("invalid uri: {}", uri))?; let file_id = state.add_mem_file(path, params.text_document.text); subs.add_sub(file_id); - return Ok(()) + return Ok(()); } Err(not) => not, }; let not = match not.cast::() { Ok(mut params) => { let uri = params.text_document.uri; - let path = uri.to_file_path() + let path = uri + .to_file_path() .map_err(|()| format_err!("invalid uri: {}", uri))?; - let text = params.content_changes.pop() + let text = params + .content_changes + .pop() .ok_or_else(|| format_err!("empty changes"))? .text; state.change_mem_file(path.as_path(), text)?; - return Ok(()) + return Ok(()); } Err(not) => not, }; let not = match not.cast::() { Ok(params) => { let uri = params.text_document.uri; - let path = uri.to_file_path() + let path = uri + .to_file_path() .map_err(|()| format_err!("invalid uri: {}", uri))?; let file_id = state.remove_mem_file(path.as_path())?; subs.remove_sub(file_id); - let params = req::PublishDiagnosticsParams { uri, diagnostics: Vec::new() }; + let params = req::PublishDiagnosticsParams { + uri, + diagnostics: Vec::new(), + }; let not = RawNotification::new::(¶ms); msg_sender.send(RawMessage::Notification(not)); - return Ok(()) + return Ok(()); } Err(not) => not, }; @@ -342,11 +342,12 @@ struct PoolDispatcher<'a> { impl<'a> PoolDispatcher<'a> { fn on<'b, R>( &'b mut self, - f: fn(ServerWorld, R::Params, JobToken) -> Result + f: fn(ServerWorld, R::Params, JobToken) -> Result, ) -> Result<&'b mut Self> - where R: req::Request, - R::Params: DeserializeOwned + Send + 'static, - R::Result: Serialize + 'static, + where + R: req::Request, + R::Params: DeserializeOwned + Send + 'static, + R::Result: Serialize + 'static, { let req = match self.req.take() { None => return Ok(self), @@ -360,16 +361,16 @@ impl<'a> PoolDispatcher<'a> { self.pool.spawn(move || { let resp = match f(world, params, token) { Ok(resp) => RawResponse::ok::(id, &resp), - Err(e) => RawResponse::err(id, ErrorCode::InternalError as i32, e.to_string()), + Err(e) => { + RawResponse::err(id, ErrorCode::InternalError as i32, e.to_string()) + } }; let task = Task::Respond(resp); sender.send(task); }); self.res = Some((id, handle)); } - Err(req) => { - self.req = Some(req) - } + Err(req) => self.req = Some(req), } Ok(self) } @@ -392,18 +393,14 @@ fn update_file_notifications_on_threadpool( pool.spawn(move || { for file_id in subscriptions { match handlers::publish_diagnostics(&world, file_id) { - Err(e) => { - error!("failed to compute diagnostics: {:?}", e) - } + Err(e) => error!("failed to compute diagnostics: {:?}", e), Ok(params) => { let not = RawNotification::new::(¶ms); sender.send(Task::Notify(not)); } } match handlers::publish_decorations(&world, file_id) { - Err(e) => { - error!("failed to compute decorations: {:?}", e) - } + Err(e) => error!("failed to compute decorations: {:?}", e), Ok(params) => { let not = RawNotification::new::(¶ms); sender.send(Task::Notify(not)) diff --git a/crates/ra_lsp_server/src/main_loop/subscriptions.rs b/crates/ra_lsp_server/src/main_loop/subscriptions.rs index 310153382..03f41e870 100644 --- a/crates/ra_lsp_server/src/main_loop/subscriptions.rs +++ b/crates/ra_lsp_server/src/main_loop/subscriptions.rs @@ -1,5 +1,5 @@ -use rustc_hash::FxHashSet; use ra_analysis::FileId; +use rustc_hash::FxHashSet; pub struct Subscriptions { subs: FxHashSet, @@ -7,7 +7,9 @@ pub struct Subscriptions { impl Subscriptions { pub fn new() -> Subscriptions { - Subscriptions { subs: FxHashSet::default() } + Subscriptions { + subs: FxHashSet::default(), + } } pub fn add_sub(&mut self, file_id: FileId) { self.subs.insert(file_id); diff --git a/crates/ra_lsp_server/src/path_map.rs b/crates/ra_lsp_server/src/path_map.rs index 19c3b1d3b..585013acd 100644 --- a/crates/ra_lsp_server/src/path_map.rs +++ b/crates/ra_lsp_server/src/path_map.rs @@ -1,11 +1,13 @@ -use std::path::{PathBuf, Path, Component}; use im; -use relative_path::RelativePath; use ra_analysis::{FileId, FileResolver}; +use relative_path::RelativePath; + +use std::path::{Component, Path, PathBuf}; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Root { - Workspace, Lib + Workspace, + Lib, } #[derive(Debug, Default, Clone)] @@ -21,7 +23,8 @@ impl PathMap { Default::default() } pub fn get_or_insert(&mut self, path: PathBuf, root: Root) -> FileId { - self.path2id.get(path.as_path()) + self.path2id + .get(path.as_path()) .map(|&id| id) .unwrap_or_else(|| { let id = self.new_file_id(); @@ -33,9 +36,7 @@ impl PathMap { self.path2id.get(path).map(|&id| id) } pub fn get_path(&self, file_id: FileId) -> &Path { - self.id2path.get(&file_id) - .unwrap() - .as_path() + self.id2path.get(&file_id).unwrap().as_path() } pub fn get_root(&self, file_id: FileId) -> Root { self.id2root[&file_id] @@ -55,7 +56,12 @@ impl PathMap { impl FileResolver for PathMap { fn file_stem(&self, file_id: FileId) -> String { - self.get_path(file_id).file_stem().unwrap().to_str().unwrap().to_string() + self.get_path(file_id) + .file_stem() + .unwrap() + .to_str() + .unwrap() + .to_string() } fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option { @@ -101,10 +107,6 @@ mod test { let mut m = PathMap::new(); let id1 = m.get_or_insert(PathBuf::from("/foo"), Root::Workspace); let id2 = m.get_or_insert(PathBuf::from("/foo/bar.rs"), Root::Workspace); - assert_eq!( - m.resolve(id1, &RelativePath::new("bar.rs")), - Some(id2), - ) + assert_eq!(m.resolve(id1, &RelativePath::new("bar.rs")), Some(id2),) } } - diff --git a/crates/ra_lsp_server/src/project_model.rs b/crates/ra_lsp_server/src/project_model.rs index c144d9596..d170ceb73 100644 --- a/crates/ra_lsp_server/src/project_model.rs +++ b/crates/ra_lsp_server/src/project_model.rs @@ -1,13 +1,12 @@ -use std::{ - path::{Path, PathBuf}, -}; -use rustc_hash::{FxHashMap, FxHashSet}; use cargo_metadata::{metadata_run, CargoOpt}; use ra_syntax::SmolStr; +use rustc_hash::{FxHashMap, FxHashSet}; + +use std::path::{Path, PathBuf}; use crate::{ + thread_watcher::{ThreadWatcher, Worker}, Result, - thread_watcher::{Worker, ThreadWatcher}, }; #[derive(Debug, Clone)] @@ -39,7 +38,12 @@ struct TargetData { #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum TargetKind { - Bin, Lib, Example, Test, Bench, Other, + Bin, + Lib, + Example, + Test, + Bench, + Other, } impl Package { @@ -49,7 +53,7 @@ impl Package { pub fn root(self, ws: &CargoWorkspace) -> &Path { ws.pkg(self).manifest.parent().unwrap() } - pub fn targets<'a>(self, ws: &'a CargoWorkspace) -> impl Iterator + 'a { + pub fn targets<'a>(self, ws: &'a CargoWorkspace) -> impl Iterator + 'a { ws.pkg(self).targets.iter().cloned() } pub fn is_member(self, ws: &CargoWorkspace) -> bool { @@ -78,13 +82,15 @@ impl CargoWorkspace { let meta = metadata_run( Some(cargo_toml.as_path()), true, - Some(CargoOpt::AllFeatures) - ).map_err(|e| format_err!("cargo metadata failed: {}", e))?; + Some(CargoOpt::AllFeatures), + ) + .map_err(|e| format_err!("cargo metadata failed: {}", e))?; let mut pkg_by_id = FxHashMap::default(); let mut packages = Vec::new(); let mut targets = Vec::new(); - let ws_members: FxHashSet = meta.workspace_members + let ws_members: FxHashSet = meta + .workspace_members .into_iter() .map(|it| it.raw) .collect(); @@ -114,7 +120,7 @@ impl CargoWorkspace { Ok(CargoWorkspace { packages, targets }) } - pub fn packages<'a>(&'a self) -> impl Iterator + 'a { + pub fn packages<'a>(&'a self) -> impl Iterator + 'a { (0..self.packages.len()).map(Package) } pub fn target_by_root(&self, root: &Path) -> Option { @@ -155,7 +161,7 @@ impl TargetKind { "example" => TargetKind::Example, _ if kind.contains("lib") => TargetKind::Lib, _ => continue, - } + }; } TargetKind::Other } @@ -170,6 +176,6 @@ pub fn workspace_loader() -> (Worker>, ThreadWat .into_iter() .map(|path| CargoWorkspace::from_cargo_metadata(path.as_path())) .for_each(|it| output_sender.send(it)) - } + }, ) } diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs index 1630edf7f..b76bfbcbc 100644 --- a/crates/ra_lsp_server/src/req.rs +++ b/crates/ra_lsp_server/src/req.rs @@ -1,20 +1,13 @@ +use languageserver_types::{Location, Position, Range, TextDocumentIdentifier, Url}; use rustc_hash::FxHashMap; -use languageserver_types::{TextDocumentIdentifier, Range, Url, Position, Location}; use url_serde; pub use languageserver_types::{ - request::*, notification::*, - InitializeResult, PublishDiagnosticsParams, - DocumentSymbolParams, DocumentSymbolResponse, - CodeActionParams, ApplyWorkspaceEditParams, - ExecuteCommandParams, - WorkspaceSymbolParams, - TextDocumentPositionParams, - TextEdit, - CompletionParams, CompletionResponse, - DocumentOnTypeFormattingParams, - TextDocumentEdit, - SignatureHelp, Hover + notification::*, request::*, ApplyWorkspaceEditParams, CodeActionParams, CompletionParams, + CompletionResponse, DocumentOnTypeFormattingParams, DocumentSymbolParams, + DocumentSymbolResponse, ExecuteCommandParams, Hover, InitializeResult, + PublishDiagnosticsParams, SignatureHelp, TextDocumentEdit, TextDocumentPositionParams, + TextEdit, WorkspaceSymbolParams, }; pub enum SyntaxTree {} @@ -28,7 +21,7 @@ impl Request for SyntaxTree { #[derive(Deserialize, Debug)] #[serde(rename_all = "camelCase")] pub struct SyntaxTreeParams { - pub text_document: TextDocumentIdentifier + pub text_document: TextDocumentIdentifier, } pub enum ExtendSelection {} @@ -94,7 +87,7 @@ pub struct PublishDecorationsParams { #[serde(rename_all = "camelCase")] pub struct Decoration { pub range: Range, - pub tag: &'static str + pub tag: &'static str, } pub enum ParentModule {} @@ -167,14 +160,14 @@ pub struct SourceChange { pub enum FileSystemEdit { CreateFile { #[serde(with = "url_serde")] - uri: Url + uri: Url, }, MoveFile { #[serde(with = "url_serde")] src: Url, #[serde(with = "url_serde")] dst: Url, - } + }, } pub enum InternalFeedback {} diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/server_world.rs index 9b3013ae8..35ff65ea1 100644 --- a/crates/ra_lsp_server/src/server_world.rs +++ b/crates/ra_lsp_server/src/server_world.rs @@ -1,18 +1,18 @@ use std::{ fs, - path::{PathBuf, Path}, + path::{Path, PathBuf}, sync::Arc, }; -use rustc_hash::FxHashMap; use languageserver_types::Url; -use ra_analysis::{FileId, AnalysisHost, Analysis, CrateGraph, CrateId, LibraryData, FileResolver}; +use ra_analysis::{Analysis, AnalysisHost, CrateGraph, CrateId, FileId, FileResolver, LibraryData}; +use rustc_hash::FxHashMap; use crate::{ - Result, path_map::{PathMap, Root}, - vfs::{FileEvent, FileEventKind}, project_model::CargoWorkspace, + vfs::{FileEvent, FileEventKind}, + Result, }; #[derive(Debug)] @@ -42,16 +42,15 @@ impl ServerWorldState { { let pm = &mut self.path_map; let mm = &mut self.mem_map; - let changes = events.into_iter() + let changes = events + .into_iter() .map(|event| { let text = match event.kind { FileEventKind::Add(text) => Some(text), }; (event.path, text) }) - .map(|(path, text)| { - (pm.get_or_insert(path, Root::Workspace), text) - }) + .map(|(path, text)| (pm.get_or_insert(path, Root::Workspace), text)) .filter_map(|(id, text)| { if mm.contains_key(&id) { mm.insert(id, text); @@ -62,12 +61,17 @@ impl ServerWorldState { }); self.analysis_host.change_files(changes); } - self.analysis_host.set_file_resolver(Arc::new(self.path_map.clone())); + self.analysis_host + .set_file_resolver(Arc::new(self.path_map.clone())); } - pub fn events_to_files(&mut self, events: Vec) -> (Vec<(FileId, String)>, Arc) { + pub fn events_to_files( + &mut self, + events: Vec, + ) -> (Vec<(FileId, String)>, Arc) { let files = { let pm = &mut self.path_map; - events.into_iter() + events + .into_iter() .map(|event| { let text = match event.kind { FileEventKind::Add(text) => text, @@ -86,7 +90,8 @@ impl ServerWorldState { pub fn add_mem_file(&mut self, path: PathBuf, text: String) -> FileId { let file_id = self.path_map.get_or_insert(path, Root::Workspace); - self.analysis_host.set_file_resolver(Arc::new(self.path_map.clone())); + self.analysis_host + .set_file_resolver(Arc::new(self.path_map.clone())); self.mem_map.insert(file_id, None); if self.path_map.get_root(file_id) != Root::Lib { self.analysis_host.change_file(file_id, Some(text)); @@ -95,9 +100,10 @@ impl ServerWorldState { } pub fn change_mem_file(&mut self, path: &Path, text: String) -> Result<()> { - let file_id = self.path_map.get_id(path).ok_or_else(|| { - format_err!("change to unknown file: {}", path.display()) - })?; + let file_id = self + .path_map + .get_id(path) + .ok_or_else(|| format_err!("change to unknown file: {}", path.display()))?; if self.path_map.get_root(file_id) != Root::Lib { self.analysis_host.change_file(file_id, Some(text)); } @@ -105,9 +111,10 @@ impl ServerWorldState { } pub fn remove_mem_file(&mut self, path: &Path) -> Result { - let file_id = self.path_map.get_id(path).ok_or_else(|| { - format_err!("change to unknown file: {}", path.display()) - })?; + let file_id = self + .path_map + .get_id(path) + .ok_or_else(|| format_err!("change to unknown file: {}", path.display()))?; match self.mem_map.remove(&file_id) { Some(_) => (), None => bail!("unmatched close notification"), @@ -122,17 +129,17 @@ impl ServerWorldState { pub fn set_workspaces(&mut self, ws: Vec) { let mut crate_roots = FxHashMap::default(); ws.iter() - .flat_map(|ws| { - ws.packages() - .flat_map(move |pkg| pkg.targets(ws)) - .map(move |tgt| tgt.root(ws)) - }) - .for_each(|root| { - if let Some(file_id) = self.path_map.get_id(root) { - let crate_id = CrateId(crate_roots.len() as u32); - crate_roots.insert(crate_id, file_id); - } - }); + .flat_map(|ws| { + ws.packages() + .flat_map(move |pkg| pkg.targets(ws)) + .map(move |tgt| tgt.root(ws)) + }) + .for_each(|root| { + if let Some(file_id) = self.path_map.get_id(root) { + let crate_id = CrateId(crate_roots.len() as u32); + crate_roots.insert(crate_id, file_id); + } + }); let crate_graph = CrateGraph { crate_roots }; self.workspaces = Arc::new(ws); self.analysis_host.set_crate_graph(crate_graph); @@ -141,7 +148,7 @@ impl ServerWorldState { ServerWorld { workspaces: Arc::clone(&self.workspaces), analysis: self.analysis_host.analysis(), - path_map: self.path_map.clone() + path_map: self.path_map.clone(), } } } @@ -152,9 +159,12 @@ impl ServerWorld { } pub fn uri_to_file_id(&self, uri: &Url) -> Result { - let path = uri.to_file_path() + let path = uri + .to_file_path() .map_err(|()| format_err!("invalid uri: {}", uri))?; - self.path_map.get_id(&path).ok_or_else(|| format_err!("unknown file: {}", path.display())) + self.path_map + .get_id(&path) + .ok_or_else(|| format_err!("unknown file: {}", path.display())) } pub fn file_id_to_uri(&self, id: FileId) -> Result { diff --git a/crates/ra_lsp_server/src/thread_watcher.rs b/crates/ra_lsp_server/src/thread_watcher.rs index 3257effcb..67952eb74 100644 --- a/crates/ra_lsp_server/src/thread_watcher.rs +++ b/crates/ra_lsp_server/src/thread_watcher.rs @@ -1,7 +1,8 @@ -use std::thread; -use crossbeam_channel::{bounded, unbounded, Sender, Receiver}; -use drop_bomb::DropBomb; use crate::Result; +use crossbeam_channel::{bounded, unbounded, Receiver, Sender}; +use drop_bomb::DropBomb; + +use std::thread; pub struct Worker { pub inp: Sender, @@ -50,11 +51,13 @@ impl ThreadWatcher { info!("waiting for {} to finish ...", self.name); let name = self.name; self.bomb.defuse(); - let res = self.thread.join() + let res = self + .thread + .join() .map_err(|_| format_err!("ThreadWatcher {} died", name)); match &res { Ok(()) => info!("... {} terminated with ok", name), - Err(_) => error!("... {} terminated with err", name) + Err(_) => error!("... {} terminated with err", name), } res } @@ -66,5 +69,9 @@ impl ThreadWatcher { fn worker_chan(buf: usize) -> ((Sender, Receiver), Receiver, Sender) { let (input_sender, input_receiver) = bounded::(buf); let (output_sender, output_receiver) = unbounded::(); - ((input_sender, output_receiver), input_receiver, output_sender) + ( + (input_sender, output_receiver), + input_receiver, + output_sender, + ) } diff --git a/crates/ra_lsp_server/src/vfs.rs b/crates/ra_lsp_server/src/vfs.rs index d8f9b1aac..417a3c19a 100644 --- a/crates/ra_lsp_server/src/vfs.rs +++ b/crates/ra_lsp_server/src/vfs.rs @@ -1,14 +1,11 @@ use std::{ - path::{PathBuf, Path}, fs, + path::{Path, PathBuf}, }; use walkdir::WalkDir; -use crate::{ - thread_watcher::{Worker, ThreadWatcher}, -}; - +use crate::thread_watcher::{ThreadWatcher, Worker}; #[derive(Debug)] pub struct FileEvent { @@ -24,7 +21,8 @@ pub enum FileEventKind { pub fn roots_loader() -> (Worker)>, ThreadWatcher) { Worker::)>::spawn( "roots loader", - 128, |input_receiver, output_sender| { + 128, + |input_receiver, output_sender| { input_receiver .into_iter() .map(|path| { @@ -34,7 +32,7 @@ pub fn roots_loader() -> (Worker)>, ThreadWatc (path, events) }) .for_each(|it| output_sender.send(it)) - } + }, ) } -- cgit v1.2.3