typhoon-syn 0.3.0

Syntax tree utilities and helpers for macro processing
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

use {
    quote::{format_ident, quote, ToTokens},
    syn::{
        fold::{fold_expr, Fold},
        parse::Parse,
        parse_quote, Expr, Ident,
    },
};

#[derive(Clone)]
pub struct ContextExpr {
    pub names: Vec<Ident>,
    expr: Expr,
}

impl Parse for ContextExpr {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let expr = Expr::parse(input)?;

        Ok(ContextExpr::from(expr.clone()))
    }
}

impl ToTokens for ContextExpr {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let expr = &self.expr;
        quote!(#expr).to_tokens(tokens)
    }
}

impl From<Expr> for ContextExpr {
    fn from(value: Expr) -> Self {
        let mut names = Names::default();
        let expr = names.fold_expr(value);
        ContextExpr {
            names: names.0,
            expr,
        }
    }
}

#[derive(Default)]
pub struct Names(Vec<Ident>);

impl Fold for Names {
    fn fold_expr(&mut self, i: syn::Expr) -> syn::Expr {
        let Expr::Try(ref try_expr) = i else {
            return fold_expr(self, i);
        };

        let Expr::MethodCall(ref method_call) = try_expr.expr.as_ref() else {
            return fold_expr(self, i);
        };

        if method_call.method != "data" {
            return fold_expr(self, i);
        }

        let Expr::Path(name) = method_call.receiver.as_ref() else {
            return fold_expr(self, i);
        };

        let Some(name_ident) = name.path.get_ident().cloned() else {
            return fold_expr(self, i);
        };

        let ident = format_ident!("{}_state", name_ident);

        self.0.push(name_ident);

        parse_quote!(#ident)
    }
}

#[cfg(test)]
mod from_expr_tests {
    use {
        super::*,
        quote::{quote, ToTokens},
        syn::parse_quote,
    };

    #[test]
    fn test_method_call_with_try() {
        // Test for pattern: counter.data()?.bump()
        let expr: Expr = parse_quote!(counter.data()?.bump());
        let context_expr = ContextExpr::from(expr);

        let inner_expr = context_expr.to_token_stream();
        let expected_expr = quote!(counter_state.bump());
        assert_eq!(expected_expr.to_string(), inner_expr.to_string());
        assert_eq!(context_expr.names.len(), 1);
    }

    #[test]
    fn test_field_access_with_try() {
        // Test for pattern: counter.data()?.bump
        let expr: Expr = parse_quote!(counter.data()?.bump);
        let context_expr = ContextExpr::from(expr);

        let inner_expr = context_expr.to_token_stream().to_string();
        let expected_expr = quote!(counter_state.bump);
        assert_eq!(expected_expr.to_string(), inner_expr.to_string());
        assert_eq!(context_expr.names.len(), 1);
    }

    #[test]
    fn test_other_expr() {
        let expr: Expr = parse_quote!(counter.random()?.bump);
        let context_expr = ContextExpr::from(expr);

        assert!(context_expr.names.is_empty());

        let inner_expr = context_expr.to_token_stream().to_string();
        let expected_expr = quote!(counter.random()?.bump);
        assert_eq!(expected_expr.to_string(), inner_expr.to_string());
    }
}