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]>

1 files changed, 80 insertions, 0 deletions

diff --git a/crates/ra_hir/src/attr.rs b/crates/ra_hir/src/attr.rs
new file mode 100644
index 000000000..f67e80bfd
--- /dev/null
+++ b/crates/ra_hir/src/attr.rs
@@ -0,0 +1,80 @@
+//! A higher level attributes based on TokenTree, with also some shortcuts.
+
+use std::sync::Arc;
+
+use mbe::ast_to_token_tree;
+use ra_cfg::CfgOptions;
+use ra_syntax::{
+    ast::{self, AstNode, AttrsOwner},
+    SmolStr,
+};
+use tt::Subtree;
+
+use crate::{db::AstDatabase, path::Path, HirFileId, Source};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct Attr {
+    pub(crate) path: Path,
+    pub(crate) input: Option<AttrInput>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AttrInput {
+    Literal(SmolStr),
+    TokenTree(Subtree),
+}
+
+impl Attr {
+    pub(crate) fn from_src(
+        Source { file_id, ast }: Source<ast::Attr>,
+        db: &impl AstDatabase,
+    ) -> Option<Attr> {
+        let path = Path::from_src(Source { file_id, ast: ast.path()? }, db)?;
+        let input = match ast.input() {
+            None => None,
+            Some(ast::AttrInput::Literal(lit)) => {
+                // FIXME: escape? raw string?
+                let value = lit.syntax().first_token()?.text().trim_matches('"').into();
+                Some(AttrInput::Literal(value))
+            }
+            Some(ast::AttrInput::TokenTree(tt)) => {
+                Some(AttrInput::TokenTree(ast_to_token_tree(&tt)?.0))
+            }
+        };
+
+        Some(Attr { path, input })
+    }
+
+    pub(crate) fn from_attrs_owner(
+        file_id: HirFileId,
+        owner: &dyn AttrsOwner,
+        db: &impl AstDatabase,
+    ) -> Option<Arc<[Attr]>> {
+        let mut attrs = owner.attrs().peekable();
+        if attrs.peek().is_none() {
+            // Avoid heap allocation
+            return None;
+        }
+        Some(attrs.flat_map(|ast| Attr::from_src(Source { file_id, ast }, db)).collect())
+    }
+
+    pub(crate) fn is_simple_atom(&self, name: &str) -> bool {
+        // FIXME: Avoid cloning
+        self.path.as_ident().map_or(false, |s| s.to_string() == name)
+    }
+
+    pub(crate) fn as_cfg(&self) -> Option<&Subtree> {
+        if self.is_simple_atom("cfg") {
+            match &self.input {
+                Some(AttrInput::TokenTree(subtree)) => Some(subtree),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> Option<bool> {
+        cfg_options.is_cfg_enabled(self.as_cfg()?)
+    }
+}