cfg-tt 0.2.0

A procedural macro that allows using #[cfg] anywhere and at token granularity.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use std::iter;

use crate::cfg::Cfg;
use proc_macro2::{Delimiter, TokenStream, TokenTree};
use syn::{
    Attribute,
    parse::{Parse, ParseStream},
};

pub struct AnyAttribute(Attribute);

impl Parse for AnyAttribute {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let content;
        let attr = Attribute {
            pound_token: input.parse()?,
            style: input
                .parse::<syn::token::Not>()
                .ok()
                .map_or_else(|| syn::AttrStyle::Outer, syn::AttrStyle::Inner),
            bracket_token: syn::bracketed!(content in input),
            meta: content.parse()?,
        };
        Ok(Self(attr))
    }
}

pub fn parse_any_attr(ts: TokenStream) -> syn::Result<Attribute> {
    syn::parse2::<AnyAttribute>(ts).map(|a| a.0)
}

pub fn find_cfg_attrs(ts: TokenStream) -> Vec<Cfg> {
    fn core(ts: TokenStream, out: &mut Vec<Cfg>) {
        let mut it = ts.into_iter().peekable();

        while let Some(tt) = it.next() {
            match &tt {
                TokenTree::Group(g) => {
                    core(g.stream(), out);
                }
                TokenTree::Punct(p) if p.as_char() == '#' => {
                    // # ...
                    let Some(TokenTree::Group(g)) = it.peek() else {
                        continue;
                    };
                    if g.delimiter() != Delimiter::Bracket {
                        continue;
                    }

                    // #[ ... ]
                    let mut attr_ts = TokenStream::new();
                    attr_ts.extend(iter::once(tt.clone()));
                    attr_ts.extend(iter::once(TokenTree::Group(g.clone())));

                    let Ok(attr) = parse_any_attr(attr_ts) else {
                        continue;
                    };
                    if let Some(cfg) = Cfg::from_attr(&attr) {
                        // #[cfg(...)]
                        out.push(cfg);
                        let _ = it.next();
                    }
                }
                _ => {}
            }
        }
    }

    let mut out = Vec::new();
    core(ts, &mut out);
    out
}