sanitizer_macros 0.2.1

Derive macro for the sanitizer crate
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::codegen::sanitization::Sanitization;
use crate::codegen::Entity;
use crate::type_ident::TypeIdent;
use proc_macro2::TokenStream;
use quote::{quote, TokenStreamExt};

pub struct StructGen {
    field_name: Entity,
    is_int: bool,
    is_option: bool,
    is_option_nested: bool,
}

impl StructGen {
    pub fn new(field_name: Entity, type_ident: &TypeIdent) -> Self {
        Self {
            field_name,
            is_int: type_ident.is_int,
            is_option: type_ident.is_option,
            is_option_nested: type_ident.is_nested,
        }
    }

    fn field_or_value(&self) -> TokenStream {
        let struct_instance = Sanitization::new(self.is_int);
        if self.is_option {
            let literal = struct_instance.literal();
            quote! {
                #literal
            }
        } else {
            let ident = &self.field_name;
            let field = struct_instance.field(&quote! { #ident });
            quote! {
                self.#field
            }
        }
    }

    fn operand(&self) -> TokenStream {
        let field = &self.field_name;
        if self.is_int {
            quote! {
                self.#field
            }
        } else {
            quote! {
                &self.#field
            }
        }
    }

    fn new_value(&self) -> TokenStream {
        let field_value = Sanitization::new(self.is_int);
        let val: TokenStream;
        if self.is_option_nested {
            val = field_value.field(&quote! { y });
        } else {
            val = field_value.field(&quote! { x });
        }
        field_value.method_calls(val)
    }

    fn call(&self) -> TokenStream {
        if self.is_option {
            if self.is_option_nested {
                quote! {
                    Some(Some(instance.get()));
                }
            } else {
                quote! {
                    Some(instance.get());
                }
            }
        } else {
            quote! {
                instance.get();
            }
        }
    }

    pub fn body(&self, sanitizers: TokenStream) -> TokenStream {
        let init = self.init();
        let operand = self.operand();
        let call = self.call();
        let mut rest = quote! {};
        let field = &self.field_name;
        if self.is_option {
            let new_value = self.new_value();
            if self.is_option_nested {
                rest.append_all(quote! {
                    if let Some(x) = #operand {
                        if let Some(y) = x {
                            instance = #new_value
                            #sanitizers
                            self.#field = #call
                        };
                    };
                })
            } else {
                rest.append_all(quote! {
                    if let Some(x) = #operand {
                        instance = #new_value
                        #sanitizers
                        self.#field = #call
                    };
                })
            };
            quote! {
                let mut instance = #init
                #rest
            }
        } else {
            quote! {
                let mut instance = #init
                #sanitizers
                self.#field = #call
            }
        }
    }

    fn init(&self) -> TokenStream {
        let init = Sanitization::new(self.is_int);
        let value = self.field_or_value();
        init.method_calls(value)
    }
}