Add cfg_attr and cleanup code

Author: wyatt-herkamp

crates/cfg/Cargo.toml

@@ -16,6 +16,7 @@ rustc-hash.workspace = true
 
 # locals deps
 tt.workspace = true
+syntax.workspace = true
 
 [dev-dependencies]
 expect-test = "1.4.1"
@@ -28,7 +29,6 @@ derive_arbitrary = "1.3.2"
 
 # local deps
 mbe.workspace = true
-syntax.workspace = true
 
 [lints]
-workspace = true
+workspace = true

crates/cfg/src/cfg_attr.rs

@@ -2,8 +2,12 @@
 //!
 //! See: <https://doc.rust-lang.org/reference/conditional-compilation.html#conditional-compilation>
 
-use std::{fmt, slice::Iter as SliceIter};
+use std::{fmt, iter::Peekable, slice::Iter as SliceIter};
 
+use syntax::{
+    ast::{self, Meta},
+    NodeOrToken,
+};
 use tt::SmolStr;
 
 /// A simple configuration value passed in from the outside.
@@ -47,6 +51,12 @@ impl CfgExpr {
     pub fn parse<S>(tt: &tt::Subtree<S>) -> CfgExpr {
         next_cfg_expr(&mut tt.token_trees.iter()).unwrap_or(CfgExpr::Invalid)
     }
+    /// Parses a `cfg` attribute from the meta
+    pub fn parse_from_attr_meta(meta: Meta) -> Option<CfgExpr> {
+        let tt = meta.token_tree()?;
+        let mut iter = tt.token_trees_and_tokens().skip(1).peekable();
+        next_cfg_expr_from_syntax(&mut iter)
+    }
     /// Fold the cfg by querying all basic `Atom` and `KeyValue` predicates.
     pub fn fold(&self, query: &dyn Fn(&CfgAtom) -> bool) -> Option<bool> {
         match self {
@@ -62,8 +72,71 @@ impl CfgExpr {
         }
     }
 }
+fn next_cfg_expr_from_syntax<I>(iter: &mut Peekable<I>) -> Option<CfgExpr>
+where
+    I: Iterator<Item = NodeOrToken<ast::TokenTree, syntax::SyntaxToken>>,
+{
+    let name = match iter.next() {
+        None => return None,
+        Some(NodeOrToken::Token(element)) => match element.kind() {
+            syntax::T![ident] => SmolStr::new(element.text()),
+            _ => return Some(CfgExpr::Invalid),
+        },
+        Some(_) => return Some(CfgExpr::Invalid),
+    };
+    let result = match name.as_str() {
+        "all" | "any" | "not" => {
+            let mut preds = Vec::new();
+            let Some(NodeOrToken::Node(tree)) = iter.next() else {
+                return Some(CfgExpr::Invalid);
+            };
+            let mut tree_iter = tree.token_trees_and_tokens().skip(1).peekable();
+            while tree_iter
+                .peek()
+                .filter(
+                    |element| matches!(element, NodeOrToken::Token(token) if (token.kind() != syntax::T![')'])),
+                )
+                .is_some()
+            {
+                let pred = next_cfg_expr_from_syntax(&mut tree_iter);
+                if let Some(pred) = pred {
+                    preds.push(pred);
+                }
+            }
+            let group = match name.as_str() {
+                "all" => CfgExpr::All(preds),
+                "any" => CfgExpr::Any(preds),
+                "not" => CfgExpr::Not(Box::new(preds.pop().unwrap_or(CfgExpr::Invalid))),
+                _ => unreachable!(),
+            };
+            Some(group)
+        }
+        _ => match iter.peek() {
+            Some(NodeOrToken::Token(element)) if (element.kind() == syntax::T![=]) => {
+                iter.next();
+                match iter.next() {
+                    Some(NodeOrToken::Token(value_token))
+                        if (value_token.kind() == syntax::SyntaxKind::STRING) =>
+                    {
+                        let value = value_token.text();
+                        let value = SmolStr::new(value.trim_matches('"'));
+                        Some(CfgExpr::Atom(CfgAtom::KeyValue { key: name, value }))
+                    }
+                    _ => None,
+                }
+            }
+            _ => Some(CfgExpr::Atom(CfgAtom::Flag(name))),
+        },
+    };
+    if let Some(NodeOrToken::Token(element)) = iter.peek() {
+        if element.kind() == syntax::T![,] {
+            iter.next();
+        }
+    }
+    result
+}
 
-pub(crate) fn next_cfg_expr<S>(it: &mut SliceIter<'_, tt::TokenTree<S>>) -> Option<CfgExpr> {
+fn next_cfg_expr<S>(it: &mut SliceIter<'_, tt::TokenTree<S>>) -> Option<CfgExpr> {
     let name = match it.next() {
         None => return None,
         Some(tt::TokenTree::Leaf(tt::Leaf::Ident(ident))) => ident.text.clone(),

crates/cfg/src/cfg_expr.rs

@@ -2,8 +2,7 @@
 
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
-mod cfg_attr;
-pub(crate) mod cfg_expr;
+mod cfg_expr;
 mod dnf;
 #[cfg(test)]
 mod tests;
@@ -13,7 +12,6 @@ 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/cfg/src/lib.rs

@@ -1,7 +1,10 @@
 use arbitrary::{Arbitrary, Unstructured};
 use expect_test::{expect, Expect};
 use mbe::{syntax_node_to_token_tree, DummyTestSpanMap, DUMMY};
-use syntax::{ast, AstNode};
+use syntax::{
+    ast::{self, Attr},
+    AstNode, SourceFile,
+};
 
 use crate::{CfgAtom, CfgExpr, CfgOptions, DnfExpr};
 
@@ -12,6 +15,22 @@ fn assert_parse_result(input: &str, expected: CfgExpr) {
     let cfg = CfgExpr::parse(&tt);
     assert_eq!(cfg, expected);
 }
+fn check_dnf_from_syntax(input: &str, expect: Expect) {
+    let parse = SourceFile::parse(input);
+    let node = match parse.tree().syntax().descendants().find_map(Attr::cast) {
+        Some(it) => it,
+        None => {
+            let node = std::any::type_name::<Attr>();
+            panic!("Failed to make ast node `{node}` from text {input}")
+        }
+    };
+    let node = node.clone_subtree();
+    assert_eq!(node.syntax().text_range().start(), 0.into());
+
+    let cfg = CfgExpr::parse_from_attr_meta(node.meta().unwrap()).unwrap();
+    let actual = format!("#![cfg({})]", DnfExpr::new(cfg));
+    expect.assert_eq(&actual);
+}
 
 fn check_dnf(input: &str, expect: Expect) {
     let source_file = ast::SourceFile::parse(input).ok().unwrap();
@@ -86,6 +105,11 @@ fn smoke() {
 
     check_dnf("#![cfg(not(a))]", expect![[r#"#![cfg(not(a))]"#]]);
 }
+#[test]
+fn cfg_from_attr() {
+    check_dnf_from_syntax(r#"#[cfg(test)]"#, expect![[r#"#![cfg(test)]"#]]);
+    check_dnf_from_syntax(r#"#[cfg(not(never))]"#, expect![[r#"#![cfg(not(never))]"#]]);
+}
 
 #[test]
 fn distribute() {