hegeltest-macros 0.27.0

Procedural macros for Hegel.
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

use proc_macro2::TokenStream;
use quote::quote;
use syn::{Attribute, ImplItem, ItemImpl};

fn is_rule(a: &Attribute) -> bool {
    a.path().is_ident("rule")
}

fn is_invariant(a: &Attribute) -> bool {
    a.path().is_ident("invariant")
}

struct MethodInfo {
    name: syn::Ident,
    attrs: Vec<Attribute>,
}

fn method_entries(methods: &[MethodInfo]) -> Vec<TokenStream> {
    methods
        .iter()
        .map(|m| {
            let name_str = m.name.to_string();
            let name = &m.name;
            // Forward the method's attributes (cfg gates, user attribute
            // macros, ...) onto the generated vec entry, except doc
            // comments: those would land on an expression and trip
            // unused_doc_comments in the user's crate.
            let attrs: Vec<&Attribute> = m
                .attrs
                .iter()
                .filter(|a| !a.path().is_ident("doc"))
                .collect();
            quote! {
                #(#attrs)*
                ::hegel::stateful::Rule::new(#name_str, Self::#name)
            }
        })
        .collect()
}

pub fn expand_state_machine(mut block: ItemImpl) -> TokenStream {
    let mut rules = Vec::new();
    let mut invariants = Vec::new();

    for item in &mut block.items {
        if let ImplItem::Fn(method) = item {
            let has_rule = method.attrs.iter().any(&is_rule);
            let has_invariant = method.attrs.iter().any(&is_invariant);
            method.attrs.retain(|a| !is_rule(a) && !is_invariant(a));

            let info = || MethodInfo {
                name: method.sig.ident.clone(),
                attrs: method.attrs.clone(),
            };
            if has_rule {
                rules.push(info());
            }
            if has_invariant {
                invariants.push(info());
            }
        }
    }

    let block_type = &block.self_ty;
    let (impl_generics, _, where_clause) = block.generics.split_for_impl();
    let rule_entries = method_entries(&rules);
    let invariant_entries = method_entries(&invariants);

    quote! {
        #block
        impl #impl_generics ::hegel::stateful::StateMachine for #block_type #where_clause {
            fn rules(&self) -> ::std::vec::Vec<::hegel::stateful::Rule<Self>> {
                ::std::vec![ #( #rule_entries ),* ]
            }
            fn invariants(&self) -> ::std::vec::Vec<::hegel::stateful::Rule<Self>> {
                ::std::vec![ #( #invariant_entries ),* ]
            }
        }
    }
}