cellular_raza-core-proc-macro 0.0.13

Cellular simulation tool
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

use quote::quote;

use super::simulation_aspects::{SimulationAspect, SimulationAspects};

#[allow(unused)]
struct MacroParser {
    test_token: syn::Ident,
    colon: syn::Token![:],
    macro_name: syn::Ident,
    comma: syn::Token![,],
    aspects: SimulationAspects,
}

impl syn::parse::Parse for MacroParser {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        Ok(Self {
            test_token: input.parse()?,
            colon: input.parse()?,
            macro_name: input.parse()?,
            comma: input.parse()?,
            aspects: input.parse()?,
        })
    }
}

impl MacroParser {
    fn spawn_tests(self) -> proc_macro2::TokenStream {
        let macro_name = &self.macro_name;
        let aspects: Vec<_> = self.aspects.to_aspect_list();
        let mut stream = quote!();
        for n in 0..aspects.len() {
            let combinations = get_combinations(n, aspects.clone());

            for (name, list) in combinations {
                let list_aspects = list.into_iter().map(|aspect| aspect.to_token_stream());
                let output = quote!(
                    #macro_name !(
                        name:#name,
                        aspects:[#(#list_aspects),*]
                    );
                );
                stream.extend(output);
            }
        }
        stream
    }
}

pub fn run_test_for_aspects(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let macro_parser = syn::parse_macro_input!(input as MacroParser);
    macro_parser.spawn_tests().into()
}

fn idents_overlap(id1: &proc_macro2::TokenStream, id2: &proc_macro2::TokenStream) -> bool {
    let id1_segments = id1.to_string();
    let id1_segments = id1_segments.split("_").collect::<Vec<_>>();
    let id2_segments = id2.to_string();
    let id2_segments = id2_segments.split("_").collect::<Vec<_>>();
    let l1 = id1_segments.len();
    let l2 = id2_segments.len();
    let set = std::collections::HashSet::<&str>::from_iter(
        id1_segments.into_iter().chain(id2_segments.into_iter()),
    );
    set.len() < l1 + l2
}

fn get_combinations(
    n: usize,
    idents: Vec<SimulationAspect>,
) -> Vec<(proc_macro2::TokenStream, Vec<SimulationAspect>)> {
    let idents: Vec<(proc_macro2::TokenStream, Vec<SimulationAspect>)> = idents
        .into_iter()
        .map(|s| (s.to_token_stream_lowercase(), vec![s]))
        .collect();

    if n == 0 {
        return idents;
    }

    fn combine_idents(
        ident1: &(proc_macro2::TokenStream, Vec<SimulationAspect>),
        ident2: &(proc_macro2::TokenStream, Vec<SimulationAspect>),
    ) -> Option<(proc_macro2::TokenStream, Vec<SimulationAspect>)> {
        if idents_overlap(&ident1.0, &ident2.0) {
            return None;
        }
        let i1 = &ident1.0;
        let i2 = &ident2.0;
        let name_ident = quote::format_ident!("{}_{}", i1.to_string(), i2.to_string());
        let name = quote!(#name_ident);
        let mut list = ident1.1.clone();
        let list2 = ident2.1.clone();
        list.extend(list2);
        let list = list.into_iter().map(|s| s.into()).collect();
        Some((name, list))
    }

    let combinations: Vec<_> = (1..n).fold(
        idents
            .iter()
            .map(|ident1| {
                idents
                    .iter()
                    .filter_map(move |ident2| combine_idents(ident1, ident2))
            })
            .flatten()
            .collect(),
        |acc, _| {
            acc.iter()
                .map(|ident1| {
                    idents
                        .iter()
                        .filter_map(move |ident2| combine_idents(ident1, ident2))
                })
                .flatten()
                .collect()
        },
    );
    combinations
}