anodized-core 0.6.0

Core interoperability for the Anodized specification system
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

#[cfg(test)]
#[path = "data_tests.rs"]
mod data_tests;

use proc_macro2::TokenStream;
use quote::ToTokens;
use syn::{ItemEnum, ItemImpl, ItemStruct, Result, parse_quote};

use crate::{DataSpec, instrument::Mode};

impl Mode {
    pub fn instrument_item_struct(
        &self,
        spec: DataSpec,
        item_struct: ItemStruct,
    ) -> Result<TokenStream> {
        let mut tokens = TokenStream::new();

        item_struct.to_tokens(&mut tokens);

        if self.changes_anything() {
            let ident = &item_struct.ident;
            let (impl_generics, ty_generics, where_clause) = item_struct.generics.split_for_impl();
            let statements = Self::build_precondition_fn_body(&[], &spec.maintains).stmts;

            let spec_impl: ItemImpl = parse_quote! {
                #[doc(hidden)]
                #[allow(warnings)]
                impl #impl_generics #ident #ty_generics #where_clause {
                    fn __anodized_data_maintains(&self) -> bool {
                        #(#statements)*
                    }
                }
            };
            spec_impl.to_tokens(&mut tokens);
        }

        Ok(tokens)
    }

    pub fn instrument_item_enum(&self, spec: DataSpec, item_enum: ItemEnum) -> Result<TokenStream> {
        let mut tokens = TokenStream::new();

        let ident = &item_enum.ident;
        let (impl_generics, ty_generics, where_clause) = item_enum.generics.split_for_impl();
        let statements = Self::build_precondition_fn_body(&[], &spec.maintains).stmts;

        item_enum.to_tokens(&mut tokens);

        if let Mode::EmbedSpecs = self {
            let spec_impl: ItemImpl = parse_quote! {
                #[doc(hidden)]
                #[allow(warnings)]
                impl #impl_generics #ident #ty_generics #where_clause {
                    fn __anodized_data_maintains(&self) -> bool {
                        // Bring all variants into scope for convenience.
                        use #ident::*;
                        #(#statements)*
                    }
                }
            };
            spec_impl.to_tokens(&mut tokens);
        }

        Ok(tokens)
    }
}