tiaojian_macro/

lib.rs

mod metadata;
mod package;

use std::{sync::RwLock, collections::HashSet};

use litrs::StringLit;
use metadata::get_metadata;
use once_cell::sync::OnceCell;
use proc_macro::TokenStream;
use syn::Token;

use crate::metadata::extract_active_pkg;

/// 存放 active_packages
static STATIC_ACTIVE_PKGS: OnceCell<RwLock<HashSet<String>>> = OnceCell::new();

fn get_active_packages() -> &'static RwLock<HashSet<String>> {
    let cache = STATIC_ACTIVE_PKGS.get_or_init(|| {
        // 解析 metadata
        let metadata = get_metadata();
        let active_pkgs = extract_active_pkg(&metadata);

        RwLock::new(active_pkgs)
    });

    cache
}

#[derive(Debug)]
struct Tiaojian {
    packages: Vec<String>,
    remove_macro: bool,
}

#[derive(Debug)]
struct TiaojianClosure {
    packages: Vec<String>,
    body: proc_macro2::TokenStream,
}

#[derive(Debug)]
struct RemoveMacro {
    rest: TokenStream
}

#[proc_macro_attribute]
pub fn tiaojian_a(attr: TokenStream, item: TokenStream) -> TokenStream {

    // syn::parse_macro_input!() 是用来只解析 #[proc_macroXXX] 的 input 的，
    // 它只能针对 #[proc_macroXXX] 能修饰的结构进行解析
    // let expr_str: proc_macro2::TokenTree = syn::parse_macro_input!(attr);

    match syn::parse::<Tiaojian>(attr) {
        Err(e) => {
            e.into_compile_error().into()
        },
        Ok(tj) => {
            // 解析 metadata
            let active_pkgs = get_active_packages();
            let active_pkgs = active_pkgs.read().unwrap();

            let all_active = tj.packages.iter().all(|pkg|
                active_pkgs.iter().any(|act_pkg| act_pkg == pkg)
            );

            if all_active {
                item
            } else {
                if tj.remove_macro {
                    let tmp = syn::parse::<RemoveMacro>(item).unwrap();
                    tmp.rest
                } else {
                    TokenStream::new()
                }
            }
        },
    }
}

///
/// ### Example :
/// 
/// ```ignore
/// tiaojian!( |packages1，| {
///     // statement...
/// });
/// ````
/// 
#[proc_macro]
pub fn tiaojian(input: TokenStream) -> TokenStream {
    match syn::parse::<TiaojianClosure>(input) {
        Err(e) => {
            e.into_compile_error().into()
        },
        Ok(tj) => {
            // 解析 metadata
            let active_pkgs = get_active_packages();
            let active_pkgs = active_pkgs.read().unwrap();

            let all_active = tj.packages.iter().all(|pkg|
                active_pkgs.iter().any(|act_pkg| act_pkg == pkg)
            );

            if all_active {
                tj.body.into()
            } else {
                TokenStream::new()
            }
        },
    }
}

impl  syn::parse::Parse for TiaojianClosure {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        input.parse::<Token![|]>()?;

        let pkg_input_iter = input.cursor().token_stream().into_iter();
        let mut packages = vec![];
        for item in pkg_input_iter {
            match item {
                proc_macro2::TokenTree::Literal(val) => {
                    let val = StringLit::try_from(val).unwrap();
                    packages.push(val.value().to_owned());
                    input.parse::<syn::LitStr>()?;
                },
                proc_macro2::TokenTree::Punct(p) => {
                    if p.to_string() =="|" {
                        break;
                    } else if p.to_string() =="," {
                        input.parse::<Token![,]>()?;
                    }
                },
                _ => Err(syn::Error::new(input.span(), "tiaojian macro not support the token".to_owned()))?,
            }
        }

        input.parse::<Token![|]>()?;
        let packages_input;
        syn::braced!(packages_input in input);
        let body = packages_input.parse::<proc_macro2::TokenStream>().unwrap();
        Ok(
            TiaojianClosure {
                packages,
                body,
            }
        )
    }
}

impl  syn::parse::Parse for RemoveMacro {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        match input.parse::<Token![#]>() {
            Ok(_) => {
                let body_buf;
                syn::bracketed!(body_buf in input);
                body_buf.parse::<proc_macro2::TokenStream>().unwrap();
                Ok(
                    Self {
                        rest: input.parse::<proc_macro2::TokenStream>().unwrap().into()
                    }
                )
            },
            Err(_) => Ok(
                Self {
                    rest: input.parse::<proc_macro2::TokenStream>().unwrap().into()
                }
            ),
        }
    }
}

/// 注意：使用 syn::parse::Parse trait，就必须将 input 全部 pasrs 完，否则抛出异常
impl syn::parse::Parse for Tiaojian {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let mut remove_macro = false;
        let fn_name: syn::Ident =  input.parse()?;
        if fn_name != "is_active" {
            return Err(syn::Error::new(input.span(), "tiaojian macro is only support build-in fn 'is_actived'  now".to_owned()));
        }
        
        let packages_input;
        syn::parenthesized!(packages_input in input);
        let pkg_input_iter = packages_input.cursor().token_stream().into_iter();
        let mut packages = vec![];

        for item in pkg_input_iter {
            match item {
                proc_macro2::TokenTree::Group(_) => {
                    return Err(syn::Error::new(input.span(), "error not support group in expression".to_owned()))
                },
                proc_macro2::TokenTree::Ident(_) => {
                    return Err(syn::Error::new(input.span(), "error not support ident in expression".to_owned()))
                },
                proc_macro2::TokenTree::Punct(v) => {
                    if v.to_string() == "," {
                        packages_input.parse::<Token![,]>()?;
                    } else {
                        return Err(syn::Error::new(input.span(), "error only support ',' in expression".to_owned()));
                    }
                },
                proc_macro2::TokenTree::Literal(val) => {
                    let val = StringLit::try_from(val).unwrap();
                    packages.push(val.value().to_owned());
                    packages_input.parse::<syn::LitStr>()?;
                },
            }
        }

        match input.parse::<Token![,]>() {
            Ok(_) => match input.parse::<syn::Ident>() {
                Ok(val) => {
                    if val == "remove_macro" {
                        remove_macro = true;
                    }
                },
                Err(_) => 
                    return Err(syn::Error::new(input.span(), "error need a ident".to_owned())),
            },
            Err(_) => {}
        }

        Ok(
            Tiaojian {
                packages,
                remove_macro
            }
        )
    }
}