subtensor-macros 0.1.0

support macros for Subtensor
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

use ahash::RandomState;
use syn::{parse_quote, visit_mut::VisitMut};

pub struct CleanDocComments;

impl CleanDocComments {
    pub fn new() -> Self {
        Self
    }
}

impl VisitMut for CleanDocComments {
    fn visit_attribute_mut(&mut self, attr: &mut syn::Attribute) {
        if attr.path().is_ident("doc") {
            *attr = parse_quote!(#[doc = ""]);
        }
        if attr.path().is_ident("freeze_struct") {
            *attr = parse_quote!(#[freeze_struct]);
        }
        syn::visit_mut::visit_attribute_mut(self, attr);
    }
}

pub fn generate_hash<T: Into<syn::Item> + Clone>(item: &T) -> u64 {
    let item = item.clone();

    // Define a fixed seed
    const SEED1: u64 = 0x12345678;
    const SEED2: u64 = 0x87654321;

    // use a fixed seed for predictable hashes
    let fixed_state = RandomState::with_seeds(SEED1, SEED2, SEED1, SEED2);

    // hash item
    let item = Into::<syn::Item>::into(item);
    fixed_state.hash_one(&item)
}

#[cfg(test)]
mod tests {
    use super::*;
    use syn::Item;

    #[test]
    fn test_clean_doc_comments() {
        // Example code with doc comments
        let item: Item = parse_quote! {
            /// This is a doc comment
            #[cfg(feature = "example")]
            fn example() {
                println!("Hello, world!");
            }
        };

        let hash_before = generate_hash(&item);

        let mut item_clone = item.clone();
        let mut cleaner = CleanDocComments;
        cleaner.visit_item_mut(&mut item_clone);

        // Calculate the hash of the cleaned item
        let hash_after = generate_hash(&item_clone);

        assert_ne!(hash_before, hash_after);

        let item2: Item = parse_quote! {
            #[doc = ""]
            #[cfg(feature = "example")]
            fn example() {
                println!("Hello, world!");
            }
        };

        assert_eq!(hash_after, generate_hash(&item2));
    }

    #[test]
    fn test_clean_doc_comments_struct() {
        // Example code with doc comments in a struct
        let item: Item = parse_quote! {
            /// Another doc comment
            struct MyStruct {
                #[cfg(feature = "field")]
                field1: i32,
                /// Field doc comment
                field2: String,
            }
        };

        let hash_before = generate_hash(&item);

        let mut item_clone = item.clone();
        let mut cleaner = CleanDocComments;
        cleaner.visit_item_mut(&mut item_clone);

        // Calculate the hash of the cleaned item
        let hash_after = generate_hash(&item_clone);

        assert_ne!(hash_before, hash_after);

        let item2: Item = parse_quote! {
            #[doc = ""]
            struct MyStruct {
                #[cfg(feature = "field")]
                field1: i32,
                #[doc = ""]
                field2: String,
            }
        };

        assert_eq!(hash_after, generate_hash(&item2));
    }
}