Merge #1928

1928: Support `#[cfg(..)]` r=matklad a=oxalica

This PR implement `#[cfg(..)]` conditional compilation. It read default cfg options from `rustc --print cfg` with also hard-coded `test` and `debug_assertion` enabled.
Front-end settings are **not** included in this PR.

There is also a known issue that inner control attributes are totally ignored. I think it is **not** a part of `cfg` and create a separated issue for it. #1949

Fixes #1920 

Related: #1073 


Co-authored-by: uHOOCCOOHu <[email protected]>
Co-authored-by: oxalica <[email protected]>

Author: bors[bot]

Cargo.lock

@@ -7,7 +7,7 @@ use rustc_hash::FxHashMap;
 use crossbeam_channel::{unbounded, Receiver};
 use ra_db::{CrateGraph, FileId, SourceRootId};
 use ra_ide_api::{AnalysisChange, AnalysisHost, FeatureFlags};
-use ra_project_model::{PackageRoot, ProjectWorkspace};
+use ra_project_model::{get_rustc_cfg_options, PackageRoot, ProjectWorkspace};
 use ra_vfs::{RootEntry, Vfs, VfsChange, VfsTask, Watch};
 use ra_vfs_glob::RustPackageFilterBuilder;
 
@@ -41,11 +41,17 @@ pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId,
         sender,
         Watch(false),
     );
-    let (crate_graph, _crate_names) = ws.to_crate_graph(&mut |path: &Path| {
-        let vfs_file = vfs.load(path);
-        log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
-        vfs_file.map(vfs_file_to_id)
-    });
+
+    // FIXME: cfg options?
+    let default_cfg_options =
+        get_rustc_cfg_options().atom("test".into()).atom("debug_assertion".into());
+
+    let (crate_graph, _crate_names) =
+        ws.to_crate_graph(&default_cfg_options, &mut |path: &Path| {
+            let vfs_file = vfs.load(path);
+            log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
+            vfs_file.map(vfs_file_to_id)
+        });
     log::debug!("crate graph: {:?}", crate_graph);
 
     let source_roots = roots

crates/ra_batch/src/lib.rs

@@ -0,0 +1,14 @@
+[package]
+edition = "2018"
+name = "ra_cfg"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+
+[dependencies]
+rustc-hash = "1.0.1"
+
+ra_syntax = { path = "../ra_syntax" }
+tt = { path = "../ra_tt", package = "ra_tt" }
+
+[dev-dependencies]
+mbe = { path = "../ra_mbe", package = "ra_mbe" }

crates/ra_cfg/Cargo.toml

@@ -0,0 +1,132 @@
+//! The condition expression used in `#[cfg(..)]` attributes.
+//!
+//! See: https://doc.rust-lang.org/reference/conditional-compilation.html#conditional-compilation
+
+use std::slice::Iter as SliceIter;
+
+use ra_syntax::SmolStr;
+use tt::{Leaf, Subtree, TokenTree};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CfgExpr {
+    Invalid,
+    Atom(SmolStr),
+    KeyValue { key: SmolStr, value: SmolStr },
+    All(Vec<CfgExpr>),
+    Any(Vec<CfgExpr>),
+    Not(Box<CfgExpr>),
+}
+
+impl CfgExpr {
+    /// Fold the cfg by querying all basic `Atom` and `KeyValue` predicates.
+    pub fn fold(&self, query: &dyn Fn(&SmolStr, Option<&SmolStr>) -> bool) -> Option<bool> {
+        match self {
+            CfgExpr::Invalid => None,
+            CfgExpr::Atom(name) => Some(query(name, None)),
+            CfgExpr::KeyValue { key, value } => Some(query(key, Some(value))),
+            CfgExpr::All(preds) => {
+                preds.iter().try_fold(true, |s, pred| Some(s && pred.fold(query)?))
+            }
+            CfgExpr::Any(preds) => {
+                preds.iter().try_fold(false, |s, pred| Some(s || pred.fold(query)?))
+            }
+            CfgExpr::Not(pred) => pred.fold(query).map(|s| !s),
+        }
+    }
+}
+
+pub fn parse_cfg(tt: &Subtree) -> CfgExpr {
+    next_cfg_expr(&mut tt.token_trees.iter()).unwrap_or(CfgExpr::Invalid)
+}
+
+fn next_cfg_expr(it: &mut SliceIter<tt::TokenTree>) -> Option<CfgExpr> {
+    let name = match it.next() {
+        None => return None,
+        Some(TokenTree::Leaf(Leaf::Ident(ident))) => ident.text.clone(),
+        Some(_) => return Some(CfgExpr::Invalid),
+    };
+
+    // Peek
+    let ret = match it.as_slice().first() {
+        Some(TokenTree::Leaf(Leaf::Punct(punct))) if punct.char == '=' => {
+            match it.as_slice().get(1) {
+                Some(TokenTree::Leaf(Leaf::Literal(literal))) => {
+                    it.next();
+                    it.next();
+                    // FIXME: escape? raw string?
+                    let value =
+                        SmolStr::new(literal.text.trim_start_matches('"').trim_end_matches('"'));
+                    CfgExpr::KeyValue { key: name, value }
+                }
+                _ => return Some(CfgExpr::Invalid),
+            }
+        }
+        Some(TokenTree::Subtree(subtree)) => {
+            it.next();
+            let mut sub_it = subtree.token_trees.iter();
+            let mut subs = std::iter::from_fn(|| next_cfg_expr(&mut sub_it)).collect();
+            match name.as_str() {
+                "all" => CfgExpr::All(subs),
+                "any" => CfgExpr::Any(subs),
+                "not" => CfgExpr::Not(Box::new(subs.pop().unwrap_or(CfgExpr::Invalid))),
+                _ => CfgExpr::Invalid,
+            }
+        }
+        _ => CfgExpr::Atom(name),
+    };
+
+    // Eat comma separator
+    if let Some(TokenTree::Leaf(Leaf::Punct(punct))) = it.as_slice().first() {
+        if punct.char == ',' {
+            it.next();
+        }
+    }
+    Some(ret)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use mbe::ast_to_token_tree;
+    use ra_syntax::ast::{self, AstNode};
+
+    fn assert_parse_result(input: &str, expected: CfgExpr) {
+        let source_file = ast::SourceFile::parse(input).ok().unwrap();
+        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
+        let (tt, _) = ast_to_token_tree(&tt).unwrap();
+        assert_eq!(parse_cfg(&tt), expected);
+    }
+
+    #[test]
+    fn test_cfg_expr_parser() {
+        assert_parse_result("#![cfg(foo)]", CfgExpr::Atom("foo".into()));
+        assert_parse_result("#![cfg(foo,)]", CfgExpr::Atom("foo".into()));
+        assert_parse_result(
+            "#![cfg(not(foo))]",
+            CfgExpr::Not(Box::new(CfgExpr::Atom("foo".into()))),
+        );
+        assert_parse_result("#![cfg(foo(bar))]", CfgExpr::Invalid);
+
+        // Only take the first
+        assert_parse_result(r#"#![cfg(foo, bar = "baz")]"#, CfgExpr::Atom("foo".into()));
+
+        assert_parse_result(
+            r#"#![cfg(all(foo, bar = "baz"))]"#,
+            CfgExpr::All(vec![
+                CfgExpr::Atom("foo".into()),
+                CfgExpr::KeyValue { key: "bar".into(), value: "baz".into() },
+            ]),
+        );
+
+        assert_parse_result(
+            r#"#![cfg(any(not(), all(), , bar = "baz",))]"#,
+            CfgExpr::Any(vec![
+                CfgExpr::Not(Box::new(CfgExpr::Invalid)),
+                CfgExpr::All(vec![]),
+                CfgExpr::Invalid,
+                CfgExpr::KeyValue { key: "bar".into(), value: "baz".into() },
+            ]),
+        );
+    }
+}

crates/ra_cfg/src/cfg_expr.rs

@@ -0,0 +1,61 @@
+//! ra_cfg defines conditional compiling options, `cfg` attibute parser and evaluator
+use std::iter::IntoIterator;
+
+use ra_syntax::SmolStr;
+use rustc_hash::FxHashSet;
+
+mod cfg_expr;
+
+pub use cfg_expr::{parse_cfg, CfgExpr};
+
+/// Configuration options used for conditional compilition on items with `cfg` attributes.
+/// We have two kind of options in different namespaces: atomic options like `unix`, and
+/// key-value options like `target_arch="x86"`.
+///
+/// Note that for key-value options, one key can have multiple values (but not none).
+/// `feature` is an example. We have both `feature="foo"` and `feature="bar"` if features
+/// `foo` and `bar` are both enabled. And here, we store key-value options as a set of tuple
+/// of key and value in `key_values`.
+///
+/// See: https://doc.rust-lang.org/reference/conditional-compilation.html#set-configuration-options
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct CfgOptions {
+    atoms: FxHashSet<SmolStr>,
+    key_values: FxHashSet<(SmolStr, SmolStr)>,
+}
+
+impl CfgOptions {
+    pub fn check(&self, cfg: &CfgExpr) -> Option<bool> {
+        cfg.fold(&|key, value| match value {
+            None => self.atoms.contains(key),
+            Some(value) => self.key_values.contains(&(key.clone(), value.clone())),
+        })
+    }
+
+    pub fn is_cfg_enabled(&self, attr: &tt::Subtree) -> Option<bool> {
+        self.check(&parse_cfg(attr))
+    }
+
+    pub fn atom(mut self, name: SmolStr) -> CfgOptions {
+        self.atoms.insert(name);
+        self
+    }
+
+    pub fn key_value(mut self, key: SmolStr, value: SmolStr) -> CfgOptions {
+        self.key_values.insert((key, value));
+        self
+    }
+
+    /// Shortcut to set features
+    pub fn features(mut self, iter: impl IntoIterator<Item = SmolStr>) -> CfgOptions {
+        for feat in iter {
+            self = self.key_value("feature".into(), feat);
+        }
+        self
+    }
+
+    pub fn remove_atom(mut self, name: &SmolStr) -> CfgOptions {
+        self.atoms.remove(name);
+        self
+    }
+}

crates/ra_cfg/src/lib.rs

@@ -10,4 +10,5 @@ relative-path = "0.4.0"
 rustc-hash = "1.0"
 
 ra_syntax = { path = "../ra_syntax" }
+ra_cfg = { path = "../ra_cfg" }
 ra_prof = { path = "../ra_prof" }

crates/ra_db/Cargo.toml

@@ -9,6 +9,7 @@
 use relative_path::{RelativePath, RelativePathBuf};
 use rustc_hash::FxHashMap;
 
+use ra_cfg::CfgOptions;
 use ra_syntax::SmolStr;
 use rustc_hash::FxHashSet;
 
@@ -109,11 +110,12 @@ struct CrateData {
     file_id: FileId,
     edition: Edition,
     dependencies: Vec<Dependency>,
+    cfg_options: CfgOptions,
 }
 
 impl CrateData {
-    fn new(file_id: FileId, edition: Edition) -> CrateData {
-        CrateData { file_id, edition, dependencies: Vec::new() }
+    fn new(file_id: FileId, edition: Edition, cfg_options: CfgOptions) -> CrateData {
+        CrateData { file_id, edition, dependencies: Vec::new(), cfg_options }
     }
 
     fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
@@ -134,13 +136,22 @@ impl Dependency {
 }
 
 impl CrateGraph {
-    pub fn add_crate_root(&mut self, file_id: FileId, edition: Edition) -> CrateId {
+    pub fn add_crate_root(
+        &mut self,
+        file_id: FileId,
+        edition: Edition,
+        cfg_options: CfgOptions,
+    ) -> CrateId {
         let crate_id = CrateId(self.arena.len() as u32);
-        let prev = self.arena.insert(crate_id, CrateData::new(file_id, edition));
+        let prev = self.arena.insert(crate_id, CrateData::new(file_id, edition, cfg_options));
         assert!(prev.is_none());
         crate_id
     }
 
+    pub fn cfg_options(&self, crate_id: CrateId) -> &CfgOptions {
+        &self.arena[&crate_id].cfg_options
+    }
+
     pub fn add_dep(
         &mut self,
         from: CrateId,
@@ -221,14 +232,14 @@ impl CrateGraph {
 
 #[cfg(test)]
 mod tests {
-    use super::{CrateGraph, Edition::Edition2018, FileId, SmolStr};
+    use super::{CfgOptions, CrateGraph, Edition::Edition2018, FileId, SmolStr};
 
     #[test]
     fn it_should_panic_because_of_cycle_dependencies() {
         let mut graph = CrateGraph::default();
-        let crate1 = graph.add_crate_root(FileId(1u32), Edition2018);
-        let crate2 = graph.add_crate_root(FileId(2u32), Edition2018);
-        let crate3 = graph.add_crate_root(FileId(3u32), Edition2018);
+        let crate1 = graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default());
+        let crate2 = graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default());
+        let crate3 = graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default());
         assert!(graph.add_dep(crate1, SmolStr::new("crate2"), crate2).is_ok());
         assert!(graph.add_dep(crate2, SmolStr::new("crate3"), crate3).is_ok());
         assert!(graph.add_dep(crate3, SmolStr::new("crate1"), crate1).is_err());
@@ -237,9 +248,9 @@ mod tests {
     #[test]
     fn it_works() {
         let mut graph = CrateGraph::default();
-        let crate1 = graph.add_crate_root(FileId(1u32), Edition2018);
-        let crate2 = graph.add_crate_root(FileId(2u32), Edition2018);
-        let crate3 = graph.add_crate_root(FileId(3u32), Edition2018);
+        let crate1 = graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default());
+        let crate2 = graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default());
+        let crate3 = graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default());
         assert!(graph.add_dep(crate1, SmolStr::new("crate2"), crate2).is_ok());
         assert!(graph.add_dep(crate2, SmolStr::new("crate3"), crate3).is_ok());
     }

crates/ra_db/src/input.rs

@@ -15,6 +15,7 @@ once_cell = "1.0.1"
 
 ra_syntax = { path = "../ra_syntax" }
 ra_arena = { path = "../ra_arena" }
+ra_cfg = { path = "../ra_cfg" }
 ra_db = { path = "../ra_db" }
 mbe = { path = "../ra_mbe", package = "ra_mbe" }
 tt = { path = "../ra_tt", package = "ra_tt" }