finny_derive 0.1.0

Procedural macros crate for the main finite state machine crate, finny.
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

use syn::{Expr, ExprMethodCall, MethodTurbofish, spanned::Spanned};

use crate::parse::FsmFnBase;


#[derive(Debug)]
pub enum FsmBlock {
    MethodCall(FsmBlockMethodCall)
}
#[derive(Debug)]
pub struct FsmBlockStruct {

}

pub fn decode_blocks(base: &FsmFnBase, item_fn: &syn::ItemFn) -> syn::Result<Vec<FsmBlock>> {
    let mut ret = vec![];

    for statement in &item_fn.block.stmts {
        match statement {
            syn::Stmt::Expr(expr) => {
                let call = decode_method_call(base, expr)?;
                ret.push(FsmBlock::MethodCall(call));
            }
            syn::Stmt::Semi(expr, _col) => {
                let call = decode_method_call(base, expr)?;
                ret.push(FsmBlock::MethodCall(call));
            }
            _ => {
                return Err(syn::Error::new(statement.span(), "Unsupported statement."));
            }
        }
    }

    Ok(ret)
}


#[derive(Debug)]
pub struct FsmBlockMethodCall {
    pub expr_call: ExprMethodCall,
    pub method_calls: Vec<ExprMethodCall>
}

pub fn decode_method_call(base: &FsmFnBase, expr: &Expr) -> syn::Result<FsmBlockMethodCall> {
    // verify if the receiver is our builder
    let mc = match expr {
        Expr::MethodCall(mc) => Ok(mc),
        _ => Err(syn::Error::new(expr.span(), "Unsupported expression. Only calls on the builder are allowed."))
    }?;

    let receiver_ident = get_method_receiver_ident(&mc.receiver)?;
    if receiver_ident != &base.builder_ident {
        return Err(syn::Error::new(receiver_ident.span(), "Only method calls referring to the FSM builder are allowed!"));
    }

    Ok(FsmBlockMethodCall {
        expr_call: mc.clone(),
        method_calls: flatten_method_calls(&mc)?
    })
}

pub fn get_method_receiver_ident(expr: &Expr) -> syn::Result<&syn::Ident> {
    let path = match expr {
        Expr::MethodCall(call) => {
            return get_method_receiver_ident(&call.receiver);
        },
        Expr::Path(ep) => Ok(ep),
        _ => {
            Err(syn::Error::new(expr.span(), "Expected a simple method receiver!"))
        }
    }?;

    let segment = match (path.path.segments.len(), path.path.segments.first()) {
        (1, Some(segment)) => Ok(segment),
        (_, _) => Err(syn::Error::new(path.path.segments.span(), "Expected a single segment"))
    }?;

    Ok(&segment.ident)
}

pub fn flatten_method_calls(mc: &ExprMethodCall) -> syn::Result<Vec<ExprMethodCall>> {
    let mut ret = vec![];
    ret.push(mc.clone());

    let mut t = &mc.receiver;
    loop {
        match **t {
            Expr::MethodCall(ref ex) => {
                ret.push(ex.clone());
                t = &ex.receiver;
            }
            Expr::Path(_) => { break; }
            _ => { return Err(syn::Error::new(mc.receiver.span(), "Unsupported.")); }
        }
    }

    ret.reverse();
    Ok(ret)
}

pub fn get_generics(turbofish: &Option<MethodTurbofish>) -> syn::Result<Vec<syn::Type>> {
    let mut ret = vec![];

    if let Some(turbofish) = turbofish {
        for arg in &turbofish.args {
            match arg {
                syn::GenericMethodArgument::Type(ty) => { ret.push(ty.clone()); },
                _ => { return Err(syn::Error::new(arg.span(), "Unsupported.")); }
            }
        }
    }

    Ok(ret)
}