predicate-macros 0.1.0

Easy to implement predicate crate traits
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! # predicate-macros
//! Easy to implement [predicate](https://github.com/Spxg/predicate) traits.
//!
//! ## Macros
//! * add_field
//! * BitAnd
//! * BitOr
//! * OpUnitTrait

use proc_macro::TokenStream;
use quote::quote;
use quote::ToTokens;
use syn::parse_macro_input;
use syn::Data;
use syn::DataEnum;
use syn::DeriveInput;
use syn::Variant;

/// Add field `Unit(OpUnitRcType<OpUnit<Self>>)` to this enum.
/// 
/// Only impl for enum, other types will panic.
#[proc_macro_attribute]
pub fn add_field(_attr: TokenStream, input: TokenStream) -> TokenStream {
    let mut item = parse_macro_input!(input as DeriveInput);
    let item_name = item.ident.clone();

    let unit_field = format!("Unit(OpUnitRcType<OpUnit<{}>>)", item_name);
    let unit_field: TokenStream = unit_field.parse().expect("parse error");
    let unit = parse_macro_input!(unit_field as Variant);

    match item.data {
        Data::Enum(DataEnum {
            ref mut variants, ..
        }) => {
            variants.push(unit);
        }
        _ => panic!("only impl for enum"),
    }

    let tokens: proc_macro2::TokenStream = item.into_token_stream();
    quote!(
        #tokens
    )
    .into()
}

/// Impl `OpUnitTrait`.
#[proc_macro_derive(OpUnitTrait)]
pub fn impl_op_unit_trait(input: TokenStream) -> TokenStream {
    let item = parse_macro_input!(input as DeriveInput);
    let item_name = &item.ident;

    quote!(
        impl OpUnitTrait for #item_name {
            fn get_op_unit(self: &OpUnitRcType<Self>) -> OpUnitRcType<OpUnit<Self>> {
                match self.as_ref() {
                    #item_name::Unit(unit) => unit.clone(),
                    _ => OpUnitRcType::new(OpUnit::new(Some(self.clone()), None, Operation::Single)),
                }
            }
        }
    )
    .into()
}

/// Impl `BitAnd`
#[proc_macro_derive(BitAnd)]
pub fn impl_bit_and(input: TokenStream) -> TokenStream {
    let item = parse_macro_input!(input as DeriveInput);
    let item_name = &item.ident;

    quote!(
        impl std::ops::BitAnd for #item_name {
            type Output = Self;

            fn bitand(self, rhs: Self) -> Self::Output {
                let node = OpUnit::new(
                    Some(OpUnitRcType::new(self)),
                    Some(OpUnitRcType::new(rhs)),
                    Operation::And,
                );
                #item_name::Unit(OpUnitRcType::new(node))
            }
        }
    )
    .into()
}

/// Impl `BitOr`
#[proc_macro_derive(BitOr)]
pub fn impl_bit_or(input: TokenStream) -> TokenStream {
    let item = parse_macro_input!(input as DeriveInput);
    let item_name = &item.ident;

    quote!(
        impl std::ops::BitOr for #item_name {
            type Output = Self;

            fn bitor(self, rhs: Self) -> Self::Output {
                let node = OpUnit::new(
                    Some(OpUnitRcType::new(self)),
                    Some(OpUnitRcType::new(rhs)),
                    Operation::Or,
                );
                #item_name::Unit(OpUnitRcType::new(node))
            }
        }
    )
    .into()
}