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
119
120
121
122
123
124
125
126

use {
    crate::{constraints::Constraints, Docs},
    proc_macro2::Span,
    syn::{
        parse_quote,
        visit::{visit_path_segment, Visit},
        Field, Ident, PathSegment,
    },
};

#[derive(Default, Clone)]
pub struct AccountMeta {
    pub is_signer: bool,
    pub is_mutable: bool,
    pub is_optional: bool,
}

#[derive(Clone)]
pub struct InstructionAccount {
    pub name: Ident,
    pub constraints: Constraints,
    pub meta: AccountMeta,
    pub docs: Vec<String>,
    ty: Option<PathSegment>,
    pub inner_ty: Ident,
}

impl InstructionAccount {
    pub fn get_ty(&self) -> PathSegment {
        let inner_ty = &self.inner_ty;
        self.ty.clone().unwrap_or(parse_quote!(#inner_ty<'info>))
    }
}

impl TryFrom<&Field> for InstructionAccount {
    type Error = syn::Error;

    fn try_from(value: &Field) -> Result<Self, Self::Error> {
        let mut acc = InstructionAccount {
            name: value
                .ident
                .clone()
                .ok_or(syn::Error::new_spanned(value, "The field need to be named"))?,
            docs: Docs::from(value.attrs.as_slice()).into_vec(),
            constraints: Constraints::try_from(value.attrs.as_slice())?,
            meta: AccountMeta::default(),
            ty: None,
            inner_ty: Ident::new("UncheckedAccount", Span::call_site()),
        };

        acc.visit_type(&value.ty);
        Ok(acc)
    }
}

impl Visit<'_> for InstructionAccount {
    fn visit_path_segment(&mut self, i: &syn::PathSegment) {
        let ty = i.ident.to_string();

        if ty == "Option" {
            self.meta.is_optional = true;
            visit_path_segment(self, i);
        } else if ty.starts_with("Mut") {
            self.meta.is_mutable = true;
            if self.ty.is_none() {
                self.ty = Some(i.clone());
            }
            visit_path_segment(self, i);
        } else if ty.ends_with("Signer") {
            self.meta.is_signer = true;
            if self.ty.is_none() {
                self.ty = Some(i.clone());
            }
            visit_path_segment(self, i);
        } else {
            if self.ty.is_none() {
                self.ty = Some(i.clone());
            }
            self.inner_ty = i.ident.clone();
            visit_path_segment(self, i);
        }
    }
}

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

    #[test]
    fn test_instruction_parse_with_context() {
        let field: syn::Field = parse_quote!(pub random2: Option<Mut<Account<Random2>>>);
        let account = InstructionAccount::try_from(&field).unwrap();
        assert_eq!(account.inner_ty, "Random2");
        assert!(account.meta.is_mutable);
        assert!(account.meta.is_optional);
        assert!(!account.meta.is_signer);

        let field: syn::Field = parse_quote!(pub random2: UncheckedSigner<'info, Account<Random2>>);
        let account = InstructionAccount::try_from(&field).unwrap();
        assert_eq!(account.inner_ty, "Random2");
        assert!(!account.meta.is_mutable);
        assert!(!account.meta.is_optional);
        assert!(account.meta.is_signer);

        let field: syn::Field = parse_quote!(pub random2: Signer<'info, Account<Random2>>);
        let account = InstructionAccount::try_from(&field).unwrap();
        assert_eq!(account.inner_ty, "Random2");
        assert!(!account.meta.is_mutable);
        assert!(!account.meta.is_optional);
        assert!(account.meta.is_signer);

        let field: syn::Field = parse_quote!(pub random2: Account<TokenAccount>);
        let account = InstructionAccount::try_from(&field).unwrap();
        assert_eq!(account.inner_ty, "TokenAccount");
        assert!(!account.meta.is_mutable);
        assert!(!account.meta.is_optional);
        assert!(!account.meta.is_signer);

        let field: syn::Field = parse_quote!(pub random2: UncheckedAccount);
        let account = InstructionAccount::try_from(&field).unwrap();
        assert_eq!(account.inner_ty, "UncheckedAccount");
        assert!(!account.meta.is_mutable);
        assert!(!account.meta.is_optional);
        assert!(!account.meta.is_signer);
    }
}