vorant_gen 0.2.0

A proc-macro library for generating state machines
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::spanned::Spanned;

use crate::{
    machine_fn::{Ctx, PointBody, PointDef, Scope, Stmts},
    save::PointSave,
};

pub struct IfPoint {
    save: PointSave,
    cond: Box<syn::Expr>,
    first_point: Box<PointBody>,
    next_points: std::vec::IntoIter<syn::Stmt>,
}

impl IfPoint {
    pub fn can_from(value: &syn::ExprIf) -> bool {
        PointSave::can_from(&value.attrs)
    }
}

impl TryFrom<syn::ExprIf> for IfPoint {
    type Error = syn::Error;

    fn try_from(value: syn::ExprIf) -> Result<Self, Self::Error> {
        let save = (value.span(), value.attrs).try_into()?;

        let mut iter_stmts = value.then_branch.stmts.into_iter();
        let body = PointBody::parse(&mut iter_stmts)?;

        if let Some(branch) = value.else_branch {
            return Err(syn::Error::new(
                branch.0.span(),
                "else branches are not supported",
            ));
        }

        Ok(IfPoint {
            save,
            cond: value.cond,
            first_point: Box::new(body),
            next_points: iter_stmts,
        })
    }
}

impl IfPoint {
    pub fn expand_call(&mut self, ctx: &Ctx) -> TokenStream {
        let Self {
            first_point,
            save,
            cond,
            ..
        } = self;

        let ident = format_ident!("If{}", ctx.if_idx);
        let first_stmts =
            first_point
                .stmts
                .expand(ctx, &Scope::If(IfScope { save }), first_point.end.is_some());

        let constructor = self.save.expand_constructor();
        let first_point = first_point.end.as_mut().map(|x| x.expand_construct(ctx));

        quote! {
            if #cond {
                #first_stmts
                #first_point
            }

            return #ident { #constructor }.offer_after();
        }
    }

    pub fn expand(
        self,
        ctx: &mut Ctx,
        mut after: Stmts,
        next: Option<&mut PointDef>,
        scope: &Scope<'_>,
    ) -> Result<TokenStream, syn::Error> {
        let Self {
            save,
            first_point,
            next_points,
            ..
        } = self;

        let machine_ident = ctx.machine_ident.clone();

        let ident = format_ident!("If{}", ctx.if_idx);
        let def = save.expand_def();

        let destructor = save.expand_destructure();
        let inner_points = if let Some(first_point) = first_point.end {
            Some(crate::machine_fn::expand_all(
                ctx,
                first_point,
                next_points,
                &Scope::If(IfScope { save: &save }),
            )?)
        } else {
            None
        };

        let outer_next = next.map(|x| x.expand_construct(ctx));
        let after = after.expand(ctx, scope, outer_next.is_some());

        let out = quote! {
            pub struct #ident {
                #def
            }

            #inner_points

            impl #ident {
                pub fn offer_after(self) -> ::vorant::Step<#machine_ident> {
                    let Self { #destructor } = self;

                    #after
                    #outer_next
                }
            }
        };

        ctx.if_idx += 1;
        Ok(out)
    }
}

pub struct IfScope<'s> {
    save: &'s PointSave,
}

impl<'s> IfScope<'s> {
    pub fn expand_end(&self, ctx: &Ctx, _expr: Option<&syn::Expr>) -> TokenStream {
        let ident = format_ident!("If{}", ctx.if_idx);
        let constructor = self.save.expand_constructor();

        quote! {
            return #ident { #constructor }.offer_after();
        }
    }
}