typhoon-context-macro 0.1.0-alpha.13

TODO
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

use {
    crate::{extractor::InnerTyExtractor, remover::AttributeRemover},
    proc_macro2::Span,
    syn::{
        spanned::Spanned, visit::Visit, visit_mut::VisitMut, Field, Ident, PathSegment, Type,
        TypePath,
    },
    typhoon_syn::constraints::{Constraints, CONSTRAINT_IDENT_STR},
};

#[derive(Clone)]
pub struct Account {
    pub name: Ident,
    pub constraints: Constraints,
    pub ty: PathSegment,
    pub is_optional: bool,
    pub inner_ty: String,
}

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

    fn try_from(value: &mut Field) -> Result<Self, Self::Error> {
        let mut inner_ty_extractor = InnerTyExtractor::new();
        inner_ty_extractor.visit_field(value);
        let inner_ty = inner_ty_extractor
            .ty
            .ok_or(syn::Error::new(value.span(), "Cannot find the inner type."))?;

        let constraints = Constraints::try_from(value.attrs.as_slice())?;
        AttributeRemover::new(CONSTRAINT_IDENT_STR).visit_field_mut(value);

        let segment = match &value.ty {
            Type::Path(TypePath { path, .. }) => path.segments.last(),
            _ => None,
        }
        .ok_or_else(|| syn::Error::new(value.span(), "Invalid type for the account."))?;

        let name = value
            .ident
            .clone()
            .unwrap_or(Ident::new("random", Span::call_site())); //TODO unit type

        let (ty, is_optional) = if segment.ident == "Option" {
            let inner_segment = get_inner(segment).ok_or_else(|| {
                syn::Error::new(segment.span(), "Invalid Option type for the account.")
            })?;
            (inner_segment, true)
        } else {
            (segment, false)
        };

        Ok(Account {
            name,
            constraints,
            ty: ty.clone(),
            is_optional,
            inner_ty,
        })
    }
}

fn get_inner(seg: &PathSegment) -> Option<&PathSegment> {
    match &seg.arguments {
        syn::PathArguments::AngleBracketed(args) => match args.args.first()? {
            syn::GenericArgument::Type(Type::Path(p)) => Some(p.path.segments.last()?),
            _ => None,
        },
        _ => None,
    }
}