nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-28 01:34:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master' into compute-lazy-assits

Browse Source 
# Conflicts:
#	crates/rust-analyzer/src/to_proto.rs
This commit is contained in:
Mikhail Rakhmanov 2020-06-02 23:22:45 +02:00
commit cb482e6351
15 changed files with 546 additions and 343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
crates/ra_ide/src/display/navigation_target.rs
View File

@ -92,15 +92,16 @@ impl NavigationTarget {
let name = module.name(db).map(|it| it.to_string().into()).unwrap_or_default();
if let Some(src) = module.declaration_source(db) {
let frange = original_range(db, src.as_ref().map(|it| it.syntax()));
return NavigationTarget::from_syntax(
let mut res = NavigationTarget::from_syntax(
frange.file_id,
name,
None,
frange.range,
src.value.syntax().kind(),
src.value.doc_comment_text(),
src.value.short_label(),
);
res.docs = src.value.doc_comment_text();
res.description = src.value.short_label();
return res;
}
module.to_nav(db)
}
@ -130,11 +131,9 @@ impl NavigationTarget {
}
/// Allows `NavigationTarget` to be created from a `NameOwner`
fn from_named(
pub(crate) fn from_named(
db: &RootDatabase,
node: InFile<&dyn ast::NameOwner>,
docs: Option<String>,
description: Option<String>,
) -> NavigationTarget {
//FIXME: use `_` instead of empty string
let name = node.value.name().map(|it| it.text().clone()).unwrap_or_default();
@ -148,8 +147,6 @@ impl NavigationTarget {
focus_range,
frange.range,
node.value.syntax().kind(),
docs,
description,
)
}
@ -159,8 +156,6 @@ impl NavigationTarget {
focus_range: Option<TextRange>,
full_range: TextRange,
kind: SyntaxKind,
docs: Option<String>,
description: Option<String>,
) -> NavigationTarget {
NavigationTarget {
file_id,
@ -169,8 +164,8 @@ impl NavigationTarget {
full_range,
focus_range,
container_name: None,
description,
docs,
description: None,
docs: None,
}
}
}
@ -238,12 +233,11 @@ where
{
fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
let src = self.source(db);
NavigationTarget::from_named(
db,
src.as_ref().map(|it| it as &dyn ast::NameOwner),
src.value.doc_comment_text(),
src.value.short_label(),
)
let mut res =
NavigationTarget::from_named(db, src.as_ref().map(|it| it as &dyn ast::NameOwner));
res.docs = src.value.doc_comment_text();
res.description = src.value.short_label();
res
}
}
@ -258,15 +252,7 @@ impl ToNav for hir::Module {
}
};
let frange = original_range(db, src.with_value(syntax));
NavigationTarget::from_syntax(
frange.file_id,
name,
focus,
frange.range,
syntax.kind(),
None,
None,
)
NavigationTarget::from_syntax(frange.file_id, name, focus, frange.range, syntax.kind())
}
}
@ -285,8 +271,6 @@ impl ToNav for hir::ImplDef {
None,
frange.range,
src.value.syntax().kind(),
None,
None,
)
}
}
@ -296,12 +280,12 @@ impl ToNav for hir::Field {
let src = self.source(db);
match &src.value {
FieldSource::Named(it) => NavigationTarget::from_named(
db,
src.with_value(it),
it.doc_comment_text(),
it.short_label(),
),
FieldSource::Named(it) => {
let mut res = NavigationTarget::from_named(db, src.with_value(it));
res.docs = it.doc_comment_text();
res.description = it.short_label();
res
}
FieldSource::Pos(it) => {
let frange = original_range(db, src.with_value(it.syntax()));
NavigationTarget::from_syntax(
@ -310,8 +294,6 @@ impl ToNav for hir::Field {
None,
frange.range,
it.syntax().kind(),
None,
None,
)
}
}
@ -322,12 +304,10 @@ impl ToNav for hir::MacroDef {
fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
let src = self.source(db);
log::debug!("nav target {:#?}", src.value.syntax());
NavigationTarget::from_named(
db,
src.as_ref().map(|it| it as &dyn ast::NameOwner),
src.value.doc_comment_text(),
None,
)
let mut res =
NavigationTarget::from_named(db, src.as_ref().map(|it| it as &dyn ast::NameOwner));
res.docs = src.value.doc_comment_text();
res
}
}

250
crates/ra_ide/src/runnables.rs
View File

@ -1,19 +1,19 @@
use std::fmt;
use hir::{AsAssocItem, Attrs, HirFileId, InFile, Semantics};
use itertools::Itertools;
use ra_cfg::CfgExpr;
use ra_ide_db::RootDatabase;
use ra_syntax::{
ast::{self, AstNode, AttrsOwner, ModuleItemOwner, NameOwner},
match_ast, SyntaxNode, TextRange,
ast::{self, AstNode, AttrsOwner, DocCommentsOwner, ModuleItemOwner, NameOwner},
match_ast, SyntaxNode,
};
use crate::FileId;
use ast::DocCommentsOwner;
use ra_cfg::CfgExpr;
use std::fmt::Display;
use crate::{display::ToNav, FileId, NavigationTarget};
#[derive(Debug)]
pub struct Runnable {
pub range: TextRange,
pub nav: NavigationTarget,
pub kind: RunnableKind,
pub cfg_exprs: Vec<CfgExpr>,
}
@ -24,8 +24,8 @@ pub enum TestId {
Path(String),
}
impl Display for TestId {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
impl fmt::Display for TestId {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
TestId::Name(name) => write!(f, "{}", name),
TestId::Path(path) => write!(f, "{}", path),
@ -131,7 +131,8 @@ fn runnable_fn(
let cfg_exprs =
attrs.by_key("cfg").tt_values().map(|subtree| ra_cfg::parse_cfg(subtree)).collect();
Some(Runnable { range: fn_def.syntax().text_range(), kind, cfg_exprs })
let nav = NavigationTarget::from_named(sema.db, InFile::new(file_id.into(), &fn_def));
Some(Runnable { nav, kind, cfg_exprs })
}
#[derive(Debug)]
@ -183,7 +184,6 @@ fn runnable_mod(
if !has_test_function {
return None;
}
let range = module.syntax().text_range();
let module_def = sema.to_def(&module)?;
let path = module_def
@ -197,7 +197,8 @@ fn runnable_mod(
let cfg_exprs =
attrs.by_key("cfg").tt_values().map(|subtree| ra_cfg::parse_cfg(subtree)).collect();
Some(Runnable { range, kind: RunnableKind::TestMod { path }, cfg_exprs })
let nav = module_def.to_nav(sema.db);
Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg_exprs })
}
#[cfg(test)]
@ -227,12 +228,38 @@ mod tests {
@r###"
[
Runnable {
range: 1..21,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 1..21,
name: "main",
kind: FN_DEF,
focus_range: Some(
12..16,
),
container_name: None,
description: None,
docs: None,
},
kind: Bin,
cfg_exprs: [],
},
Runnable {
range: 22..46,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 22..46,
name: "test_foo",
kind: FN_DEF,
focus_range: Some(
33..41,
),
container_name: None,
description: None,
docs: None,
},
kind: Test {
test_id: Path(
"test_foo",
@ -244,7 +271,20 @@ mod tests {
cfg_exprs: [],
},
Runnable {
range: 47..81,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 47..81,
name: "test_foo",
kind: FN_DEF,
focus_range: Some(
68..76,
),
container_name: None,
description: None,
docs: None,
},
kind: Test {
test_id: Path(
"test_foo",
@ -279,12 +319,38 @@ mod tests {
@r###"
[
Runnable {
range: 1..21,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 1..21,
name: "main",
kind: FN_DEF,
focus_range: Some(
12..16,
),
container_name: None,
description: None,
docs: None,
},
kind: Bin,
cfg_exprs: [],
},
Runnable {
range: 22..64,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 22..64,
name: "foo",
kind: FN_DEF,
focus_range: Some(
56..59,
),
container_name: None,
description: None,
docs: None,
},
kind: DocTest {
test_id: Path(
"foo",
@ -319,12 +385,38 @@ mod tests {
@r###"
[
Runnable {
range: 1..21,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 1..21,
name: "main",
kind: FN_DEF,
focus_range: Some(
12..16,
),
container_name: None,
description: None,
docs: None,
},
kind: Bin,
cfg_exprs: [],
},
Runnable {
range: 51..105,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 51..105,
name: "foo",
kind: FN_DEF,
focus_range: Some(
97..100,
),
container_name: None,
description: None,
docs: None,
},
kind: DocTest {
test_id: Path(
"Data::foo",
@ -354,14 +446,40 @@ mod tests {
@r###"
[
Runnable {
range: 1..59,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 1..59,
name: "test_mod",
kind: MODULE,
focus_range: Some(
13..21,
),
container_name: None,
description: None,
docs: None,
},
kind: TestMod {
path: "test_mod",
},
cfg_exprs: [],
},
Runnable {
range: 28..57,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 28..57,
name: "test_foo1",
kind: FN_DEF,
focus_range: Some(
43..52,
),
container_name: None,
description: None,
docs: None,
},
kind: Test {
test_id: Path(
"test_mod::test_foo1",
@ -396,14 +514,40 @@ mod tests {
@r###"
[
Runnable {
range: 23..85,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 23..85,
name: "test_mod",
kind: MODULE,
focus_range: Some(
27..35,
),
container_name: None,
description: None,
docs: None,
},
kind: TestMod {
path: "foo::test_mod",
},
cfg_exprs: [],
},
Runnable {
range: 46..79,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 46..79,
name: "test_foo1",
kind: FN_DEF,
focus_range: Some(
65..74,
),
container_name: None,
description: None,
docs: None,
},
kind: Test {
test_id: Path(
"foo::test_mod::test_foo1",
@ -440,14 +584,40 @@ mod tests {
@r###"
[
Runnable {
range: 41..115,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 41..115,
name: "test_mod",
kind: MODULE,
focus_range: Some(
45..53,
),
container_name: None,
description: None,
docs: None,
},
kind: TestMod {
path: "foo::bar::test_mod",
},
cfg_exprs: [],
},
Runnable {
range: 68..105,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 68..105,
name: "test_foo1",
kind: FN_DEF,
focus_range: Some(
91..100,
),
container_name: None,
description: None,
docs: None,
},
kind: Test {
test_id: Path(
"foo::bar::test_mod::test_foo1",
@ -479,7 +649,20 @@ mod tests {
@r###"
[
Runnable {
range: 1..58,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 1..58,
name: "test_foo1",
kind: FN_DEF,
focus_range: Some(
44..53,
),
container_name: None,
description: None,
docs: None,
},
kind: Test {
test_id: Path(
"test_foo1",
@ -516,7 +699,20 @@ mod tests {
@r###"
[
Runnable {
range: 1..80,
nav: NavigationTarget {
file_id: FileId(
1,
),
full_range: 1..80,
name: "test_foo1",
kind: FN_DEF,
focus_range: Some(
66..75,
),
container_name: None,
description: None,
docs: None,
},
kind: Test {
test_id: Path(
"test_foo1",

2
crates/ra_project_model/src/cargo_workspace.rs
View File

@ -64,7 +64,7 @@ impl Default for CargoConfig {
fn default() -> Self {
CargoConfig {
no_default_features: false,
all_features: true,
all_features: false,
features: Vec::new(),
load_out_dirs_from_check: false,
target: None,

3
crates/rust-analyzer/src/caps.rs
View File

@ -87,6 +87,9 @@ pub fn server_capabilities(client_caps: &ClientCapabilities) -> ServerCapabiliti
"ssr": true,
"onEnter": true,
"parentModule": true,
"runnables": {
"kinds": [ "cargo" ],
},
})),
}
}

85
crates/rust-analyzer/src/cargo_target_spec.rs
View File

@ -1,10 +1,10 @@
//! See `CargoTargetSpec`
use ra_cfg::CfgExpr;
use ra_ide::{FileId, RunnableKind, TestId};
use ra_project_model::{self, ProjectWorkspace, TargetKind};
use crate::{world::WorldSnapshot, Result};
use ra_syntax::SmolStr;
/// Abstract representation of Cargo target.
///
@ -21,7 +21,7 @@ impl CargoTargetSpec {
pub(crate) fn runnable_args(
spec: Option<CargoTargetSpec>,
kind: &RunnableKind,
features_needed: &Vec<SmolStr>,
cfgs: &[CfgExpr],
) -> Result<(Vec<String>, Vec<String>)> {
let mut args = Vec::new();
let mut extra_args = Vec::new();
@ -76,10 +76,14 @@ impl CargoTargetSpec {
}
}
features_needed.iter().for_each(|feature| {
let mut features = Vec::new();
for cfg in cfgs {
required_features(cfg, &mut features);
}
for feature in features {
args.push("--features".to_string());
args.push(feature.to_string());
});
args.push(feature);
}
Ok((args, extra_args))
}
@ -140,3 +144,74 @@ impl CargoTargetSpec {
}
}
}
/// Fill minimal features needed
fn required_features(cfg_expr: &CfgExpr, features: &mut Vec<String>) {
match cfg_expr {
CfgExpr::KeyValue { key, value } if key == "feature" => features.push(value.to_string()),
CfgExpr::All(preds) => {
preds.iter().for_each(|cfg| required_features(cfg, features));
}
CfgExpr::Any(preds) => {
for cfg in preds {
let len_features = features.len();
required_features(cfg, features);
if len_features != features.len() {
break;
}
}
}
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use mbe::{ast_to_token_tree, TokenMap};
use ra_cfg::parse_cfg;
use ra_syntax::{
ast::{self, AstNode},
SmolStr,
};
fn get_token_tree_generated(input: &str) -> (tt::Subtree, TokenMap) {
let source_file = ast::SourceFile::parse(input).ok().unwrap();
let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
ast_to_token_tree(&tt).unwrap()
}
#[test]
fn test_cfg_expr_minimal_features_needed() {
let (subtree, _) = get_token_tree_generated(r#"#![cfg(feature = "baz")]"#);
let cfg_expr = parse_cfg(&subtree);
let mut min_features = vec![];
required_features(&cfg_expr, &mut min_features);
assert_eq!(min_features, vec![SmolStr::new("baz")]);
let (subtree, _) =
get_token_tree_generated(r#"#![cfg(all(feature = "baz", feature = "foo"))]"#);
let cfg_expr = parse_cfg(&subtree);
let mut min_features = vec![];
required_features(&cfg_expr, &mut min_features);
assert_eq!(min_features, vec![SmolStr::new("baz"), SmolStr::new("foo")]);
let (subtree, _) =
get_token_tree_generated(r#"#![cfg(any(feature = "baz", feature = "foo", unix))]"#);
let cfg_expr = parse_cfg(&subtree);
let mut min_features = vec![];
required_features(&cfg_expr, &mut min_features);
assert_eq!(min_features, vec![SmolStr::new("baz")]);
let (subtree, _) = get_token_tree_generated(r#"#![cfg(foo)]"#);
let cfg_expr = parse_cfg(&subtree);
let mut min_features = vec![];
required_features(&cfg_expr, &mut min_features);
assert!(min_features.is_empty());
}
}

2
crates/rust-analyzer/src/config.rs
View File

@ -123,7 +123,7 @@ impl Default for Config {
check: Some(FlycheckConfig::CargoCommand {
command: "check".to_string(),
all_targets: true,
all_features: true,
all_features: false,
extra_args: Vec::new(),
}),

31
crates/rust-analyzer/src/lsp_ext.rs
View File

@ -4,7 +4,6 @@ use std::{collections::HashMap, path::PathBuf};
use lsp_types::request::Request;
use lsp_types::{Position, Range, TextDocumentIdentifier};
use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize};
pub enum AnalyzerStatus {}
@ -128,7 +127,7 @@ pub enum Runnables {}
impl Request for Runnables {
type Params = RunnablesParams;
type Result = Vec<Runnable>;
const METHOD: &'static str = "rust-analyzer/runnables";
const METHOD: &'static str = "experimental/runnables";
}
#[derive(Serialize, Deserialize, Debug)]
@ -138,25 +137,31 @@ pub struct RunnablesParams {
pub position: Option<Position>,
}
// Must strictly correspond to the executable name
#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Runnable {
pub label: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<lsp_types::LocationLink>,
pub kind: RunnableKind,
pub args: CargoRunnable,
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
pub enum RunnableKind {
Cargo,
Rustc,
Rustup,
}
#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Runnable {
pub range: Range,
pub label: String,
pub kind: RunnableKind,
pub args: Vec<String>,
pub extra_args: Vec<String>,
pub env: FxHashMap<String, String>,
pub cwd: Option<PathBuf>,
pub struct CargoRunnable {
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_root: Option<PathBuf>,
// command, --package and --lib stuff
pub cargo_args: Vec<String>,
// stuff after --
pub executable_args: Vec<String>,
}
pub enum InlayHints {}

165
crates/rust-analyzer/src/main_loop/handlers.rs
View File

@ -17,15 +17,12 @@ use lsp_types::{
SemanticTokensParams, SemanticTokensRangeParams, SemanticTokensRangeResult,
SemanticTokensResult, SymbolInformation, TextDocumentIdentifier, Url, WorkspaceEdit,
};
use ra_cfg::CfgExpr;
use ra_ide::{
FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind, SearchScope,
TextEdit,
FileId, FilePosition, FileRange, Query, RangeInfo, RunnableKind, SearchScope, TextEdit,
};
use ra_prof::profile;
use ra_project_model::TargetKind;
use ra_syntax::{AstNode, SmolStr, SyntaxKind, TextRange, TextSize};
use rustc_hash::FxHashMap;
use ra_syntax::{AstNode, SyntaxKind, TextRange, TextSize};
use serde::{Deserialize, Serialize};
use serde_json::to_value;
use stdx::format_to;
@ -403,7 +400,7 @@ pub fn handle_runnables(
let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?;
for runnable in world.analysis().runnables(file_id)? {
if let Some(offset) = offset {
if !runnable.range.contains_inclusive(offset) {
if !runnable.nav.full_range().contains_inclusive(offset) {
continue;
}
}
@ -416,7 +413,7 @@ pub fn handle_runnables(
}
}
}
res.push(to_lsp_runnable(&world, file_id, runnable)?);
res.push(to_proto::runnable(&world, file_id, runnable)?);
}
// Add `cargo check` and `cargo test` for the whole package
@ -424,25 +421,31 @@ pub fn handle_runnables(
Some(spec) => {
for &cmd in ["check", "test"].iter() {
res.push(lsp_ext::Runnable {
range: Default::default(),
label: format!("cargo {} -p {}", cmd, spec.package),
location: None,
kind: lsp_ext::RunnableKind::Cargo,
args: vec![cmd.to_string(), "--package".to_string(), spec.package.clone()],
extra_args: Vec::new(),
env: FxHashMap::default(),
cwd: workspace_root.map(|root| root.to_owned()),
args: lsp_ext::CargoRunnable {
workspace_root: workspace_root.map(|root| root.to_owned()),
cargo_args: vec![
cmd.to_string(),
"--package".to_string(),
spec.package.clone(),
],
executable_args: Vec::new(),
},
})
}
}
None => {
res.push(lsp_ext::Runnable {
range: Default::default(),
label: "cargo check --workspace".to_string(),
location: None,
kind: lsp_ext::RunnableKind::Cargo,
args: vec!["check".to_string(), "--workspace".to_string()],
extra_args: Vec::new(),
env: FxHashMap::default(),
cwd: workspace_root.map(|root| root.to_owned()),
args: lsp_ext::CargoRunnable {
workspace_root: workspace_root.map(|root| root.to_owned()),
cargo_args: vec!["check".to_string(), "--workspace".to_string()],
executable_args: Vec::new(),
},
});
}
}
@ -755,11 +758,11 @@ pub fn handle_code_action(
if world.config.client_caps.resolve_code_action {
for assist in world.analysis().unresolved_assists(&world.config.assist, frange)?.into_iter()
{
res.push(to_proto::unresolved_code_action(&world, assist)?.into());
res.push(to_proto::unresolved_code_action(&world, assist)?);
}
} else {
for assist in world.analysis().resolved_assists(&world.config.assist, frange)?.into_iter() {
res.push(to_proto::resolved_code_action(&world, assist)?.into());
res.push(to_proto::resolved_code_action(&world, assist)?);
}
}
@ -782,7 +785,7 @@ pub fn handle_resolve_code_action(
let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
for assist in world.analysis().resolved_assists(&world.config.assist, frange)?.into_iter() {
res.push(to_proto::resolved_code_action(&world, assist)?.into());
res.push(to_proto::resolved_code_action(&world, assist)?);
}
Ok(res
.into_iter()
@ -833,10 +836,11 @@ pub fn handle_code_lens(
}
};
let mut r = to_lsp_runnable(&world, file_id, runnable)?;
let range = to_proto::range(&line_index, runnable.nav.range());
let r = to_proto::runnable(&world, file_id, runnable)?;
if world.config.lens.run {
let lens = CodeLens {
range: r.range,
range,
command: Some(Command {
title: run_title.to_string(),
command: "rust-analyzer.runSingle".into(),
@ -848,13 +852,8 @@ pub fn handle_code_lens(
}
if debugee && world.config.lens.debug {
if r.args[0] == "run" {
r.args[0] = "build".into();
} else {
r.args.push("--no-run".into());
}
let debug_lens = CodeLens {
range: r.range,
range,
command: Some(Command {
title: "Debug".into(),
command: "rust-analyzer.debugSingle".into(),
@ -1008,65 +1007,6 @@ pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<Dia
Ok(DiagnosticTask::SetNative(file_id, diagnostics))
}
fn to_lsp_runnable(
world: &WorldSnapshot,
file_id: FileId,
runnable: Runnable,
) -> Result<lsp_ext::Runnable> {
let spec = CargoTargetSpec::for_file(world, file_id)?;
let target = spec.as_ref().map(|s| s.target.clone());
let mut features_needed = vec![];
for cfg_expr in &runnable.cfg_exprs {
collect_minimal_features_needed(cfg_expr, &mut features_needed);
}
let (args, extra_args) =
CargoTargetSpec::runnable_args(spec, &runnable.kind, &features_needed)?;
let line_index = world.analysis().file_line_index(file_id)?;
let label = match &runnable.kind {
RunnableKind::Test { test_id, .. } => format!("test {}", test_id),
RunnableKind::TestMod { path } => format!("test-mod {}", path),
RunnableKind::Bench { test_id } => format!("bench {}", test_id),
RunnableKind::DocTest { test_id, .. } => format!("doctest {}", test_id),
RunnableKind::Bin => {
target.map_or_else(|| "run binary".to_string(), |t| format!("run {}", t))
}
};
Ok(lsp_ext::Runnable {
range: to_proto::range(&line_index, runnable.range),
label,
kind: lsp_ext::RunnableKind::Cargo,
args,
extra_args,
env: {
let mut m = FxHashMap::default();
m.insert("RUST_BACKTRACE".to_string(), "short".to_string());
m
},
cwd: world.workspace_root_for(file_id).map(|root| root.to_owned()),
})
}
/// Fill minimal features needed
fn collect_minimal_features_needed(cfg_expr: &CfgExpr, features: &mut Vec<SmolStr>) {
match cfg_expr {
CfgExpr::KeyValue { key, value } if key == "feature" => features.push(value.clone()),
CfgExpr::All(preds) => {
preds.iter().for_each(|cfg| collect_minimal_features_needed(cfg, features));
}
CfgExpr::Any(preds) => {
for cfg in preds {
let len_features = features.len();
collect_minimal_features_needed(cfg, features);
if len_features != features.len() {
break;
}
}
}
_ => {}
}
}
pub fn handle_inlay_hints(
world: WorldSnapshot,
params: InlayHintsParams,
@ -1203,54 +1143,3 @@ pub fn handle_semantic_tokens_range(
let semantic_tokens = to_proto::semantic_tokens(&text, &line_index, highlights);
Ok(Some(semantic_tokens.into()))
}
#[cfg(test)]
mod tests {
use super::*;
use mbe::{ast_to_token_tree, TokenMap};
use ra_cfg::parse_cfg;
use ra_syntax::{
ast::{self, AstNode},
SmolStr,
};
fn get_token_tree_generated(input: &str) -> (tt::Subtree, TokenMap) {
let source_file = ast::SourceFile::parse(input).ok().unwrap();
let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
ast_to_token_tree(&tt).unwrap()
}
#[test]
fn test_cfg_expr_minimal_features_needed() {
let (subtree, _) = get_token_tree_generated(r#"#![cfg(feature = "baz")]"#);
let cfg_expr = parse_cfg(&subtree);
let mut min_features = vec![];
collect_minimal_features_needed(&cfg_expr, &mut min_features);
assert_eq!(min_features, vec![SmolStr::new("baz")]);
let (subtree, _) =
get_token_tree_generated(r#"#![cfg(all(feature = "baz", feature = "foo"))]"#);
let cfg_expr = parse_cfg(&subtree);
let mut min_features = vec![];
collect_minimal_features_needed(&cfg_expr, &mut min_features);
assert_eq!(min_features, vec![SmolStr::new("baz"), SmolStr::new("foo")]);
let (subtree, _) =
get_token_tree_generated(r#"#![cfg(any(feature = "baz", feature = "foo", unix))]"#);
let cfg_expr = parse_cfg(&subtree);
let mut min_features = vec![];
collect_minimal_features_needed(&cfg_expr, &mut min_features);
assert_eq!(min_features, vec![SmolStr::new("baz")]);
let (subtree, _) = get_token_tree_generated(r#"#![cfg(foo)]"#);
let cfg_expr = parse_cfg(&subtree);
let mut min_features = vec![];
collect_minimal_features_needed(&cfg_expr, &mut min_features);
assert!(min_features.is_empty());
}
}

38
crates/rust-analyzer/src/to_proto.rs
View File

@ -4,12 +4,14 @@ use ra_ide::{
Assist, CompletionItem, CompletionItemKind, Documentation, FileSystemEdit, Fold, FoldKind,
FunctionSignature, Highlight, HighlightModifier, HighlightTag, HighlightedRange, Indel,
InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget, ReferenceAccess,
ResolvedAssist, Severity, SourceChange, SourceFileEdit, TextEdit,
ResolvedAssist, Runnable, RunnableKind, Severity, SourceChange, SourceFileEdit, TextEdit,
};
use ra_syntax::{SyntaxKind, TextRange, TextSize};
use ra_vfs::LineEndings;
use crate::{lsp_ext, semantic_tokens, world::WorldSnapshot, Result};
use crate::{
cargo_target_spec::CargoTargetSpec, lsp_ext, semantic_tokens, world::WorldSnapshot, Result,
};
pub(crate) fn position(line_index: &LineIndex, offset: TextSize) -> lsp_types::Position {
let line_col = line_index.line_col(offset);
@ -658,3 +660,35 @@ pub(crate) fn resolved_code_action(
};
Ok(res)
}
pub(crate) fn runnable(
world: &WorldSnapshot,
file_id: FileId,
runnable: Runnable,
) -> Result<lsp_ext::Runnable> {
let spec = CargoTargetSpec::for_file(world, file_id)?;
let target = spec.as_ref().map(|s| s.target.clone());
let (cargo_args, executable_args) =
CargoTargetSpec::runnable_args(spec, &runnable.kind, &runnable.cfg_exprs)?;
let label = match &runnable.kind {
RunnableKind::Test { test_id, .. } => format!("test {}", test_id),
RunnableKind::TestMod { path } => format!("test-mod {}", path),
RunnableKind::Bench { test_id } => format!("bench {}", test_id),
RunnableKind::DocTest { test_id, .. } => format!("doctest {}", test_id),
RunnableKind::Bin => {
target.map_or_else(|| "run binary".to_string(), |t| format!("run {}", t))
}
};
let location = location_link(world, None, runnable.nav)?;
Ok(lsp_ext::Runnable {
label,
location: Some(location),
kind: lsp_ext::RunnableKind::Cargo,
args: lsp_ext::CargoRunnable {
workspace_root: world.workspace_root_for(file_id).map(|root| root.to_owned()),
cargo_args,
executable_args,
},
})
}

113
crates/rust-analyzer/tests/heavy_tests/main.rs
View File

@ -76,30 +76,33 @@ fn foo() {
server.request::<Runnables>(
RunnablesParams { text_document: server.doc_id("lib.rs"), position: None },
json!([
{
"args": [ "test" ],
"extraArgs": [ "foo", "--nocapture" ],
"kind": "cargo",
"env": { "RUST_BACKTRACE": "short" },
"cwd": null,
"label": "test foo",
"range": {
"end": { "character": 1, "line": 2 },
"start": { "character": 0, "line": 0 }
{
"args": {
"cargoArgs": ["test"],
"executableArgs": ["foo", "--nocapture"],
},
"kind": "cargo",
"label": "test foo",
"location": {
"targetRange": {
"end": { "character": 1, "line": 2 },
"start": { "character": 0, "line": 0 }
},
"targetSelectionRange": {
"end": { "character": 6, "line": 1 },
"start": { "character": 3, "line": 1 }
},
"targetUri": "file:///[..]/lib.rs"
}
},
{
"args": {
"cargoArgs": ["check", "--workspace"],
"executableArgs": [],
},
"kind": "cargo",
"label": "cargo check --workspace"
}
},
{
"args": ["check", "--workspace"],
"extraArgs": [],
"kind": "cargo",
"env": {},
"cwd": null,
"label": "cargo check --workspace",
"range": {
"end": { "character": 0, "line": 0 },
"start": { "character": 0, "line": 0 }
}
}
]),
);
}
@ -138,42 +141,44 @@ fn main() {}
server.request::<Runnables>(
RunnablesParams { text_document: server.doc_id("foo/tests/spam.rs"), position: None },
json!([
{
"args": [ "test", "--package", "foo", "--test", "spam" ],
"extraArgs": [ "test_eggs", "--exact", "--nocapture" ],
"kind": "cargo",
"env": { "RUST_BACKTRACE": "short" },
"label": "test test_eggs",
"range": {
{
"args": {
"cargoArgs": ["test", "--package", "foo", "--test", "spam"],
"executableArgs": ["test_eggs", "--exact", "--nocapture"],
"workspaceRoot": server.path().join("foo")
},
"kind": "cargo",
"label": "test test_eggs",
"location": {
"targetRange": {
"end": { "character": 17, "line": 1 },
"start": { "character": 0, "line": 0 }
},
"cwd": server.path().join("foo")
},
{
"args": [ "check", "--package", "foo" ],
"extraArgs": [],
"kind": "cargo",
"env": {},
"label": "cargo check -p foo",
"range": {
"end": { "character": 0, "line": 0 },
"start": { "character": 0, "line": 0 }
"targetSelectionRange": {
"end": { "character": 12, "line": 1 },
"start": { "character": 3, "line": 1 }
},
"cwd": server.path().join("foo")
},
{
"args": [ "test", "--package", "foo" ],
"extraArgs": [],
"kind": "cargo",
"env": {},
"label": "cargo test -p foo",
"range": {
"end": { "character": 0, "line": 0 },
"start": { "character": 0, "line": 0 }
},
"cwd": server.path().join("foo")
"targetUri": "file:///[..]/tests/spam.rs"
}
},
{
"args": {
"cargoArgs": ["check", "--package", "foo"],
"executableArgs": [],
"workspaceRoot": server.path().join("foo")
},
"kind": "cargo",
"label": "cargo check -p foo"
},
{
"args": {
"cargoArgs": ["test", "--package", "foo"],
"executableArgs": [],
"workspaceRoot": server.path().join("foo")
},
"kind": "cargo",
"label": "cargo test -p foo"
}
]),
);
}

80
docs/dev/lsp-extensions.md
View File

@ -311,6 +311,50 @@ Moreover, it would be cool if editors didn't need to implement even basic langua
This is how `SelectionRange` request works.
* Alternatively, should we perhaps flag certain `SelectionRange`s as being brace pairs?
## Runnables
**Issue:** https://github.com/microsoft/language-server-protocol/issues/944
**Server Capability:** `{ "runnables": { "kinds": string[] } }`
This request is send from client to server to get the list of things that can be run (tests, binaries, `cargo check -p`).
**Method:** `experimental/runnables`
**Request:**
```typescript
interface RunnablesParams {
textDocument: TextDocumentIdentifier;
/// If null, compute runnables for the whole file.
position?: Position;
}
```
**Response:** `Runnable[]`
```typescript
interface Runnable {
label: string;
/// If this Runnable is associated with a specific function/module, etc, the location of this item
location?: LocationLink;
/// Running things is necessary technology specific, `kind` needs to be advertised via server capabilities,
// the type of `args` is specific to `kind`. The actual running is handled by the client.
kind: string;
args: any;
}
```
rust-analyzer supports only one `kind`, `"cargo"`. The `args` for `"cargo"` look like this:
```typescript
{
workspaceRoot?: string;
cargoArgs: string[];
executableArgs: string[];
}
```
## Analyzer Status
**Method:** `rust-analyzer/analyzerStatus`
@ -399,39 +443,3 @@ interface InlayHint {
label: string,
}
```
## Runnables
**Method:** `rust-analyzer/runnables`
This request is send from client to server to get the list of things that can be run (tests, binaries, `cargo check -p`).
Note that we plan to move this request to `experimental/runnables`, as it is not really Rust-specific, but the current API is not necessary the right one.
Upstream issue: https://github.com/microsoft/language-server-protocol/issues/944
**Request:**
```typescript
interface RunnablesParams {
textDocument: TextDocumentIdentifier;
/// If null, compute runnables for the whole file.
position?: Position;
}
```
**Response:** `Runnable[]`
```typescript
interface Runnable {
/// The range this runnable is applicable for.
range: lc.Range;
/// The label to show in the UI.
label: string;
/// The following fields describe a process to spawn.
kind: "cargo" | "rustc" | "rustup";
args: string[];
/// Args for cargo after `--`.
extraArgs: string[];
env: { [key: string]: string };
cwd: string | null;
}
```

4
editors/code/package.json
View File

@ -238,7 +238,7 @@
},
"rust-analyzer.cargo.allFeatures": {
"type": "boolean",
"default": true,
"default": false,
"description": "Activate all available features"
},
"rust-analyzer.cargo.features": {
@ -319,7 +319,7 @@
},
"rust-analyzer.checkOnSave.allFeatures": {
"type": "boolean",
"default": true,
"default": false,
"markdownDescription": "Check with all features (will be passed as `--all-features`)"
},
"rust-analyzer.inlayHints.enable": {

12
editors/code/src/debug.ts
View File

@ -114,8 +114,8 @@ async function getDebugConfiguration(ctx: Ctx, runnable: ra.Runnable): Promise<v
}
async function getDebugExecutable(runnable: ra.Runnable): Promise<string> {
const cargo = new Cargo(runnable.cwd || '.', debugOutput);
const executable = await cargo.executableFromArgs(runnable.args);
const cargo = new Cargo(runnable.args.workspaceRoot || '.', debugOutput);
const executable = await cargo.executableFromArgs(runnable.args.cargoArgs);
// if we are here, there were no compilation errors.
return executable;
@ -127,8 +127,8 @@ function getLldbDebugConfig(runnable: ra.Runnable, executable: string, sourceFil
request: "launch",
name: runnable.label,
program: executable,
args: runnable.extraArgs,
cwd: runnable.cwd,
args: runnable.args.executableArgs,
cwd: runnable.args.workspaceRoot,
sourceMap: sourceFileMap,
sourceLanguages: ["rust"]
};
@ -140,8 +140,8 @@ function getCppvsDebugConfig(runnable: ra.Runnable, executable: string, sourceFi
request: "launch",
name: runnable.label,
program: executable,
args: runnable.extraArgs,
cwd: runnable.cwd,
args: runnable.args.executableArgs,
cwd: runnable.args.workspaceRoot,
sourceFileMap: sourceFileMap,
};
}

17
editors/code/src/lsp_ext.ts
View File

@ -53,18 +53,17 @@ export interface RunnablesParams {
position: lc.Position | null;
}
export type RunnableKind = "cargo" | "rustc" | "rustup";
export interface Runnable {
range: lc.Range;
label: string;
kind: RunnableKind;
args: string[];
extraArgs: string[];
env: { [key: string]: string };
cwd: string | null;
location?: lc.LocationLink;
kind: "cargo";
args: {
workspaceRoot?: string;
cargoArgs: string[];
executableArgs: string[];
};
}
export const runnables = new lc.RequestType<RunnablesParams, Runnable[], void>("rust-analyzer/runnables");
export const runnables = new lc.RequestType<RunnablesParams, Runnable[], void>("experimental/runnables");
export type InlayHint = InlayHint.TypeHint | InlayHint.ParamHint | InlayHint.ChainingHint;

21
editors/code/src/run.ts
View File

@ -103,18 +103,27 @@ interface CargoTaskDefinition extends vscode.TaskDefinition {
env?: { [key: string]: string };
}
export function createTask(spec: ra.Runnable): vscode.Task {
export function createTask(runnable: ra.Runnable): vscode.Task {
const TASK_SOURCE = 'Rust';
let command;
switch (runnable.kind) {
case "cargo": command = toolchain.getPathForExecutable("cargo");
}
const args = runnable.args.cargoArgs;
if (runnable.args.executableArgs.length > 0) {
args.push('--', ...runnable.args.executableArgs);
}
const definition: CargoTaskDefinition = {
type: 'cargo',
label: spec.label,
command: toolchain.getPathForExecutable(spec.kind),
args: spec.extraArgs ? [...spec.args, '--', ...spec.extraArgs] : spec.args,
env: Object.assign({}, process.env, spec.env),
label: runnable.label,
command,
args,
env: Object.assign({}, process.env as { [key: string]: string }, { "RUST_BACKTRACE": "short" }),
};
const execOption: vscode.ShellExecutionOptions = {
cwd: spec.cwd || '.',
cwd: runnable.args.workspaceRoot || '.',
env: definition.env,
};
const exec = new vscode.ShellExecution(