Merge branch 'cfg_attr' of https://github.com/wyatt-herkamp/rust-analyzer into cfg_attr

Author: wyatt-herkamp

crates/cfg/src/cfg_attr.rs

@@ -0,0 +1,70 @@
+use std::{
+    fmt::{self, Debug},
+    slice::Iter as SliceIter,
+};
+
+use crate::{cfg_expr::next_cfg_expr, CfgAtom, CfgExpr};
+use tt::{Delimiter, SmolStr, Span};
+/// Represents a `#[cfg_attr(.., my_attr)]` attribute.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CfgAttr<S> {
+    /// Expression in `cfg_attr` attribute.
+    pub cfg_expr: CfgExpr,
+    /// Inner attribute.
+    pub attr: tt::Subtree<S>,
+}
+
+impl<S: Clone + Span + Debug> CfgAttr<S> {
+    /// Parses a sub tree in the form of (cfg_expr, inner_attribute)
+    pub fn parse(tt: &tt::Subtree<S>) -> Option<CfgAttr<S>> {
+        let mut iter = tt.token_trees.iter();
+        let cfg_expr = next_cfg_expr(&mut iter).unwrap_or(CfgExpr::Invalid);
+        // FIXME: This is probably not the right way to do this
+        // Get's the span of the next token tree
+        let first_span = iter.as_slice().first().map(|tt| tt.first_span())?;
+        let attr = tt::Subtree {
+            delimiter: Delimiter::invisible_spanned(first_span),
+            token_trees: iter.cloned().collect(),
+        };
+        Some(CfgAttr { cfg_expr, attr: attr })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use expect_test::{expect, Expect};
+    use mbe::{syntax_node_to_token_tree, DummyTestSpanMap, DUMMY};
+    use syntax::{ast, AstNode};
+
+    use crate::{CfgAttr, DnfExpr};
+
+    fn check_dnf(input: &str, expected_dnf: Expect, expected_attrs: Expect) {
+        let source_file = ast::SourceFile::parse(input).ok().unwrap();
+        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
+        let tt = syntax_node_to_token_tree(tt.syntax(), DummyTestSpanMap, DUMMY);
+        let Some(CfgAttr { cfg_expr, attr }) = CfgAttr::parse(&tt) else {
+            assert!(false, "failed to parse cfg_attr");
+            return;
+        };
+
+        let actual = format!("#![cfg({})]", DnfExpr::new(cfg_expr));
+        expected_dnf.assert_eq(&actual);
+        let actual_attrs = format!("#![{}]", attr);
+        expected_attrs.assert_eq(&actual_attrs);
+    }
+
+    #[test]
+    fn smoke() {
+        check_dnf(
+            r#"#![cfg_attr(feature = "nightly", feature(slice_split_at_unchecked))]"#,
+            expect![[r#"#![cfg(feature = "nightly")]"#]],
+            expect![r#"#![feature (slice_split_at_unchecked)]"#],
+        );
+
+        check_dnf(
+            r#"#![cfg_attr(not(feature = "std"), no_std)]"#,
+            expect![[r#"#![cfg(not(feature = "std"))]"#]],
+            expect![r#"#![no_std]"#],
+        );
+    }
+}

crates/cfg/src/lib.rs

@@ -2,7 +2,7 @@
 
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
-pub mod cfg_expr;
+mod cfg_expr;
 mod dnf;
 #[cfg(test)]
 mod tests;
@@ -12,6 +12,7 @@ use std::fmt;
 use rustc_hash::FxHashSet;
 use tt::SmolStr;
 
+pub use cfg_attr::CfgAttr;
 pub use cfg_expr::{CfgAtom, CfgExpr};
 pub use dnf::DnfExpr;
 

crates/hir-expand/src/db.rs

@@ -10,6 +10,7 @@ use syntax::{
     ast::{self, HasAttrs},
     AstNode, Parse, SyntaxElement, SyntaxError, SyntaxNode, SyntaxToken, T,
 };
+use tracing::info;
 use triomphe::Arc;
 
 use crate::{
@@ -461,7 +462,14 @@ fn macro_arg(
         }
     }
 }
-
+fn censor_cfg_elements(
+    node: &SyntaxNode,
+    loc: &MacroCallLoc,
+    span_map: &SpanMap,
+    db: &dyn ExpandDatabase,
+) -> FxHashSet<SyntaxElement> {
+    cfg_process::process_cfg_attrs(node, loc, span_map, db).unwrap_or_default()
+}
 // FIXME: Censoring info should be calculated by the caller! Namely by name resolution
 /// Certain macro calls expect some nodes in the input to be preprocessed away, namely:
 /// - derives expect all `#[derive(..)]` invocations up to the currently invoked one to be stripped

crates/hir-expand/src/fixup.rs

@@ -52,6 +52,7 @@ pub(crate) fn fixup_syntax(
 ) -> SyntaxFixups {
     let mut append = FxHashMap::<SyntaxElement, _>::default();
     let mut remove = FxHashSet::<SyntaxElement>::default();
+    let mut remove = FxHashSet::<SyntaxElement>::default();
     let mut preorder = node.preorder();
     let mut original = Vec::new();
     let dummy_range = FIXUP_DUMMY_RANGE;
@@ -68,6 +69,7 @@ pub(crate) fn fixup_syntax(
 
         let node_range = node.text_range();
         if can_handle_error(&node) && has_error_to_handle(&node) {
+            remove.insert(node.clone().into());
             remove.insert(node.clone().into());
             // the node contains an error node, we have to completely replace it by something valid
             let original_tree = mbe::syntax_node_to_token_tree(&node, span_map, call_site);

crates/mbe/src/syntax_bridge.rs

@@ -9,6 +9,7 @@ use syntax::{
     SyntaxKind::{self, *},
     SyntaxNode, SyntaxToken, SyntaxTreeBuilder, TextRange, TextSize, WalkEvent, T,
 };
+use tracing::info;
 use tt::{
     buffer::{Cursor, TokenBuffer},
     Span,