language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-02 06:41:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Merge #500

Browse source 
500: Code lens support for running tests r=matklad a=kjeremy

Supports running individual and mod tests.

I feel like this kind of abuses the `Runnables` infrastructure but it works. Maybe later on down the line we should introduce a struct that is really just a tuple of binary, arguments, and environment and pass that back to the client instead. `run_single.ts` is just a paired down version of `runnables.ts` and there is duplication because I think run_single will probably change independent of runnables.

Co-authored-by: Jeremy A. Kolb <jkolb@ara.com>
Co-authored-by: Jeremy Kolb <kjeremy@gmail.com>
This commit is contained in:
bors[bot] 2019-01-12 18:56:11 +00:00
commit e56072bfa3
8 changed files with 173 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

141
crates/ra_lsp_server/src/main_loop/handlers.rs
View file

@ -2,7 +2,7 @@ use std::collections::HashMap;
use gen_lsp_server::ErrorCode;
use languageserver_types::{
CodeActionResponse, Command, Diagnostic, DiagnosticSeverity, DocumentFormattingParams,
CodeActionResponse, Command, CodeLens, Diagnostic, DiagnosticSeverity, DocumentFormattingParams,
DocumentHighlight, DocumentSymbol, Documentation, FoldingRange, FoldingRangeKind,
FoldingRangeParams, Hover, HoverContents, Location, MarkupContent, MarkupKind,
ParameterInformation, ParameterLabel, Position, PrepareRenameResponse, Range, RenameParams,
@ -17,8 +17,8 @@ use serde_json::to_value;
use std::io::Write;
use crate::{
cargo_target_spec::{CargoTargetSpec, runnable_args},
conv::{to_location, to_location_link, Conv, ConvWith, MapConvWith, TryConvWith},
project_model::TargetKind,
req::{self, Decoration},
server_world::ServerWorld,
LspError, Result,
@ -291,99 +291,6 @@ pub fn handle_runnables(
env: FxHashMap::default(),
});
return Ok(res);
fn runnable_args(
world: &ServerWorld,
file_id: FileId,
kind: &RunnableKind,
) -> Result<Vec<String>> {
let spec = CargoTargetSpec::for_file(world, file_id)?;
let mut res = Vec::new();
match kind {
RunnableKind::Test { name } => {
res.push("test".to_string());
if let Some(spec) = spec {
spec.push_to(&mut res);
}
res.push("--".to_string());
res.push(name.to_string());
res.push("--nocapture".to_string());
}
RunnableKind::TestMod { path } => {
res.push("test".to_string());
if let Some(spec) = spec {
spec.push_to(&mut res);
}
res.push("--".to_string());
res.push(path.to_string());
res.push("--nocapture".to_string());
}
RunnableKind::Bin => {
res.push("run".to_string());
if let Some(spec) = spec {
spec.push_to(&mut res);
}
}
}
Ok(res)
}
struct CargoTargetSpec {
package: String,
target: String,
target_kind: TargetKind,
}
impl CargoTargetSpec {
fn for_file(world: &ServerWorld, file_id: FileId) -> Result<Option<CargoTargetSpec>> {
let &crate_id = match world.analysis().crate_for(file_id)?.first() {
Some(crate_id) => crate_id,
None => return Ok(None),
};
let file_id = world.analysis().crate_root(crate_id)?;
let path = world
.vfs
.read()
.file2path(ra_vfs::VfsFile(file_id.0.into()));
let res = world.workspaces.iter().find_map(|ws| {
let tgt = ws.cargo.target_by_root(&path)?;
let res = CargoTargetSpec {
package: tgt.package(&ws.cargo).name(&ws.cargo).to_string(),
target: tgt.name(&ws.cargo).to_string(),
target_kind: tgt.kind(&ws.cargo),
};
Some(res)
});
Ok(res)
}
fn push_to(self, buf: &mut Vec<String>) {
buf.push("--package".to_string());
buf.push(self.package);
match self.target_kind {
TargetKind::Bin => {
buf.push("--bin".to_string());
buf.push(self.target);
}
TargetKind::Test => {
buf.push("--test".to_string());
buf.push(self.target);
}
TargetKind::Bench => {
buf.push("--bench".to_string());
buf.push(self.target);
}
TargetKind::Example => {
buf.push("--example".to_string());
buf.push(self.target);
}
TargetKind::Lib => {
buf.push("--lib".to_string());
}
TargetKind::Other => (),
}
}
}
}
pub fn handle_decorations(
@ -669,6 +576,50 @@ pub fn handle_code_action(
Ok(Some(CodeActionResponse::Commands(res)))
}
pub fn handle_code_lens(
world: ServerWorld,
params: req::CodeLensParams,
) -> Result<Option<Vec<CodeLens>>> {
let file_id = params.text_document.try_conv_with(&world)?;
let line_index = world.analysis().file_line_index(file_id);
let mut lenses: Vec<CodeLens> = Default::default();
for runnable in world.analysis().runnables(file_id)? {
match &runnable.kind {
RunnableKind::Test { name: _ } | RunnableKind::TestMod { path: _ } => {
let args = runnable_args(&world, file_id, &runnable.kind)?;
let range = runnable.range.conv_with(&line_index);
// This represents the actual command that will be run.
let r: req::Runnable = req::Runnable {
range,
label: Default::default(),
bin: "cargo".into(),
args,
env: Default::default(),
};
let lens = CodeLens {
range,
command: Some(Command {
title: "Run Test".into(),
command: "ra-lsp.run-single".into(),
arguments: Some(vec![to_value(r).unwrap()]),
}),
data: None,
};
lenses.push(lens);
}
_ => continue,
};
}
return Ok(Some(lenses));
}
pub fn handle_document_highlight(
world: ServerWorld,
params: req::TextDocumentPositionParams,