//! See `CargoTargetSpec`
-use ra_ide::{FileId, RunnableKind, TestId};
-use ra_project_model::{self, ProjectWorkspace, TargetKind};
+use cfg::{CfgAtom, CfgExpr};
+use ide::{FileId, RunnableKind, TestId};
+use project_model::{self, TargetKind};
+use vfs::AbsPathBuf;
-use crate::{world::WorldSnapshot, Result};
+use crate::{global_state::GlobalStateSnapshot, Result};
/// Abstract representation of Cargo target.
///
/// build/test/run the target.
#[derive(Clone)]
pub(crate) struct CargoTargetSpec {
+ pub(crate) workspace_root: AbsPathBuf,
+ pub(crate) cargo_toml: AbsPathBuf,
pub(crate) package: String,
pub(crate) target: String,
pub(crate) target_kind: TargetKind,
impl CargoTargetSpec {
pub(crate) fn runnable_args(
+ snap: &GlobalStateSnapshot,
spec: Option<CargoTargetSpec>,
kind: &RunnableKind,
+ cfg: &Option<CfgExpr>,
) -> Result<(Vec<String>, Vec<String>)> {
let mut args = Vec::new();
let mut extra_args = Vec::new();
RunnableKind::Test { test_id, attr } => {
args.push("test".to_string());
if let Some(spec) = spec {
- spec.push_to(&mut args);
+ spec.push_to(&mut args, kind);
}
extra_args.push(test_id.to_string());
if let TestId::Path(_) = test_id {
}
extra_args.push("--nocapture".to_string());
if attr.ignore {
- extra_args.push("--ignored".to_string())
+ extra_args.push("--ignored".to_string());
}
}
RunnableKind::TestMod { path } => {
args.push("test".to_string());
if let Some(spec) = spec {
- spec.push_to(&mut args);
+ spec.push_to(&mut args, kind);
}
extra_args.push(path.to_string());
extra_args.push("--nocapture".to_string());
RunnableKind::Bench { test_id } => {
args.push("bench".to_string());
if let Some(spec) = spec {
- spec.push_to(&mut args);
+ spec.push_to(&mut args, kind);
}
extra_args.push(test_id.to_string());
if let TestId::Path(_) = test_id {
}
extra_args.push("--nocapture".to_string());
}
+ RunnableKind::DocTest { test_id } => {
+ args.push("test".to_string());
+ args.push("--doc".to_string());
+ if let Some(spec) = spec {
+ spec.push_to(&mut args, kind);
+ }
+ extra_args.push(test_id.to_string());
+ extra_args.push("--nocapture".to_string());
+ }
RunnableKind::Bin => {
- args.push("run".to_string());
+ let subcommand = match spec {
+ Some(CargoTargetSpec { target_kind: TargetKind::Test, .. }) => "test",
+ _ => "run",
+ };
+ args.push(subcommand.to_string());
if let Some(spec) = spec {
- spec.push_to(&mut args);
+ spec.push_to(&mut args, kind);
}
}
}
+
+ let cargo_config = snap.config.cargo();
+ if cargo_config.all_features {
+ args.push("--all-features".to_string());
+ } else {
+ let mut features = Vec::new();
+ if let Some(cfg) = cfg.as_ref() {
+ required_features(cfg, &mut features);
+ }
+ for feature in cargo_config.features {
+ features.push(feature.clone());
+ }
+ features.dedup();
+ for feature in features {
+ args.push("--features".to_string());
+ args.push(feature);
+ }
+ }
+
Ok((args, extra_args))
}
pub(crate) fn for_file(
- world: &WorldSnapshot,
+ global_state_snapshot: &GlobalStateSnapshot,
file_id: FileId,
) -> Result<Option<CargoTargetSpec>> {
- let &crate_id = match world.analysis().crate_for(file_id)?.first() {
- Some(crate_id) => crate_id,
+ let crate_id = match global_state_snapshot.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.file_id_to_path(file_id);
- let res = world.workspaces.iter().find_map(|ws| match ws {
- ProjectWorkspace::Cargo { cargo, .. } => {
- let tgt = cargo.target_by_root(&path)?;
- Some(CargoTargetSpec {
- package: cargo.package_flag(&cargo[cargo[tgt].package]),
- target: cargo[tgt].name.clone(),
- target_kind: cargo[tgt].kind,
- })
- }
- ProjectWorkspace::Json { .. } => None,
- });
- Ok(res)
+ let (cargo_ws, target) = match global_state_snapshot.cargo_target_for_crate_root(crate_id) {
+ Some(it) => it,
+ None => return Ok(None),
+ };
+
+ let target_data = &cargo_ws[target];
+ let package_data = &cargo_ws[target_data.package];
+ let res = CargoTargetSpec {
+ workspace_root: cargo_ws.workspace_root().to_path_buf(),
+ cargo_toml: package_data.manifest.clone(),
+ package: cargo_ws.package_flag(&package_data),
+ target: target_data.name.clone(),
+ target_kind: target_data.kind,
+ };
+
+ Ok(Some(res))
}
- pub(crate) fn push_to(self, buf: &mut Vec<String>) {
+ pub(crate) fn push_to(self, buf: &mut Vec<String>, kind: &RunnableKind) {
buf.push("--package".to_string());
buf.push(self.package);
+
+ // Can't mix --doc with other target flags
+ if let RunnableKind::DocTest { .. } = kind {
+ return;
+ }
match self.target_kind {
TargetKind::Bin => {
buf.push("--bin".to_string());
}
}
}
+
+/// Fill minimal features needed
+fn required_features(cfg_expr: &CfgExpr, features: &mut Vec<String>) {
+ match cfg_expr {
+ CfgExpr::Atom(CfgAtom::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 cfg::CfgExpr;
+ use mbe::ast_to_token_tree;
+ use syntax::{
+ ast::{self, AstNode},
+ SmolStr,
+ };
+
+ fn check(cfg: &str, expected_features: &[&str]) {
+ let cfg_expr = {
+ let source_file = ast::SourceFile::parse(cfg).ok().unwrap();
+ let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
+ let (tt, _) = ast_to_token_tree(&tt);
+ CfgExpr::parse(&tt)
+ };
+
+ let mut features = vec![];
+ required_features(&cfg_expr, &mut features);
+
+ let expected_features =
+ expected_features.iter().map(|&it| SmolStr::new(it)).collect::<Vec<_>>();
+
+ assert_eq!(features, expected_features);
+ }
+
+ #[test]
+ fn test_cfg_expr_minimal_features_needed() {
+ check(r#"#![cfg(feature = "baz")]"#, &["baz"]);
+ check(r#"#![cfg(all(feature = "baz", feature = "foo"))]"#, &["baz", "foo"]);
+ check(r#"#![cfg(any(feature = "baz", feature = "foo", unix))]"#, &["baz"]);
+ check(r#"#![cfg(foo)]"#, &[]);
+ }
+}
projects / rust.git / blobdiff