tailcall-impl 1.0.1

The procedural macro implementation for the tailcall crate
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

use proc_macro2::Ident;
use syn::{fold::Fold, *};

use super::helpers::{Binding, RewriteForBindLater};

pub fn apply_fn_tailcall_transform(item_fn: ItemFn) -> ItemFn {
    FnTailcallTransformer::new().fold_item_fn(item_fn)
}

struct FnTailcallTransformer;

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

impl Fold for FnTailcallTransformer {
    fn fold_item_fn(&mut self, item_fn: ItemFn) -> ItemFn {
        let ItemFn {
            attrs,
            vis,
            mut sig,
            block,
        } = item_fn;

        let binding = sig.bind_later();
        let binding_pat = binding.tuple_pat();
        let binding_expr = binding.tuple_expr();

        let block = apply_fn_tailcall_body_transform(&sig.ident, *block);

        let block = parse_quote! {
            {
                let mut tailcall_trampoline_state = #binding_expr;

                'tailcall_trampoline_loop: loop {
                    let #binding_pat = tailcall_trampoline_state;
                    return #block;
                }
            }
        };

        ItemFn {
            attrs,
            vis,
            sig,
            block,
        }
    }
}

pub fn apply_fn_tailcall_body_transform(fn_name_ident: &Ident, block: Block) -> Block {
    FnTailCallBodyTransformer::new(fn_name_ident).fold_block(block)
}

struct FnTailCallBodyTransformer<'a> {
    fn_name_ident: &'a Ident,
}

impl<'a> FnTailCallBodyTransformer<'a> {
    pub fn new(fn_name_ident: &'a Ident) -> Self {
        Self { fn_name_ident }
    }

    fn try_rewrite_call_expr(&mut self, expr: &Expr) -> Option<Expr> {
        if let Expr::Call(ExprCall { func, args, .. }) = expr {
            if let Expr::Path(ExprPath { ref path, .. }) = **func {
                if let Some(ident) = path.get_ident() {
                    if ident == self.fn_name_ident {
                        let args = self.fold_expr_tuple(parse_quote! { (#args) });

                        return Some(parse_quote! {
                            {
                                tailcall_trampoline_state = #args;
                                continue 'tailcall_trampoline_loop;
                            }
                        });
                    }
                }
            }
        }

        None
    }

    fn try_rewrite_return_expr(&mut self, expr: &Expr) -> Option<Expr> {
        if let Expr::Return(ExprReturn {
            expr: Some(expr), ..
        }) = expr
        {
            return self.try_rewrite_expr(expr);
        }

        None
    }

    fn try_rewrite_expr(&mut self, expr: &Expr) -> Option<Expr> {
        self.try_rewrite_return_expr(expr)
            .or_else(|| self.try_rewrite_call_expr(expr))
    }
}

impl Fold for FnTailCallBodyTransformer<'_> {
    fn fold_expr(&mut self, expr: Expr) -> Expr {
        self.try_rewrite_expr(&expr)
            .unwrap_or_else(|| fold::fold_expr(self, expr))
    }

    fn fold_expr_closure(&mut self, expr_closure: ExprClosure) -> ExprClosure {
        // The meaning of the `return` keyword changes here -- stop transforming
        expr_closure
    }

    fn fold_item_fn(&mut self, item_fn: ItemFn) -> ItemFn {
        // The meaning of the `return` keyword changes here -- stop transforming
        item_fn
    }
}