Minor

crates/rust-analyzer/src/cargo_target_spec.rs

@@ -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());
+    }
+}