repetitive 0.3.2

Macro for generating repetitive code
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

use proc_macro2::{Delimiter, Group, TokenStream};
use syn::{Token, parse::ParseStream};

use super::*;

#[derive(Debug, Clone)]
pub struct FragmentFor {
    pub for_token: Token![for],
    pub iters: Vec<FragmentForIter>,
    pub body: Tokens,
}

#[derive(Debug, Clone)]
pub struct FragmentForIter {
    pub pat: Pattern,
    pub iter: Expr,
}

impl ContextParse for FragmentFor {
    fn ctx_parse(input: ParseStream, ctx: &mut Context) -> Result<Self, Error>
    where
        Self: Sized,
    {
        let for_token = <Token![for]>::ctx_parse(input, ctx)?;

        let mut iters = Vec::new();
        while Pattern::peek(input) {
            let iter = FragmentForIter::ctx_parse(input, ctx)?;
            iters.push(iter);

            if !input.peek(Token![,]) {
                break;
            }

            <Token![,]>::ctx_parse(input, ctx)?;
        }

        let body_group = Group::ctx_parse(input, ctx)?;
        if body_group.delimiter() != Delimiter::Brace {
            return Err(Error::ParseError(syn::Error::new(
                body_group.span(),
                "expected a brace-delimited block",
            )));
        }

        let body = Tokens::ctx_parse.ctx_parse2(body_group.stream(), ctx)?;

        return Ok(Self {
            for_token,
            iters,
            body,
        });
    }
}
impl ContextParse for FragmentForIter {
    fn ctx_parse(input: ParseStream, ctx: &mut Context) -> Result<Self, Error>
    where
        Self: Sized,
    {
        let pat = Pattern::ctx_parse(input, ctx)?;

        <Token![in]>::ctx_parse(input, ctx)?;

        let iter = Expr::ctx_parse(input, ctx)?;

        Ok(Self { pat, iter })
    }
}

impl Peek for FragmentFor {
    fn peek(input: ParseStream) -> bool {
        input.peek(Token![for])
    }
}

impl Optimize for FragmentFor {
    fn optimize(&mut self, ctx: &mut Context) {
        self.body.optimize(ctx);
    }
}

impl Expand for FragmentFor {
    fn expand(&self, output: &mut TokenStream, ctx: &mut Context, namespace: &Namespace) {
        self.expand_recursive(0, output, ctx, namespace);
    }
}
impl FragmentFor {
    fn expand_recursive(
        &self,
        iter_idx: usize,
        output: &mut TokenStream,
        ctx: &mut Context,
        namespace: &Namespace,
    ) {
        let iter = &self.iters[iter_idx];
        let iter_items = iter.iter.eval(ctx, namespace);

        let iter_items = match iter_items.kind {
            ValueKind::Unknown(_) => return,

            ValueKind::List(val) => val,
            _ => {
                ctx.push_error(Error::ExpectedFound {
                    span: iter_items.span,
                    expected: "list",
                    found: iter_items.kind.kind_str(),
                });
                return;
            }
        };

        for item in iter_items {
            let mut item_namespace = namespace.fork();
            iter.pat.queue_insert(item, &mut item_namespace, ctx);
            item_namespace.flush();

            if self.iters.get(iter_idx + 1).is_some() {
                self.expand_recursive(iter_idx + 1, output, ctx, &mut item_namespace);
            } else {
                self.body.expand(output, ctx, &mut item_namespace);
            }
        }
    }
}