rama-macros 0.2.0-alpha.2

procedural macross for rama
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
127
128
129
130
131
132

use proc_macro2::{Ident, TokenStream};
use quote::quote_spanned;
use syn::{
    parse::{Parse, ParseStream},
    spanned::Spanned,
    Field, ItemStruct, Token,
};

use crate::{
    attr_parsing::{combine_unary_attribute, parse_attrs, Combine},
    type_parsing::extract_type_from_arc,
};

pub(crate) fn expand(item: ItemStruct) -> syn::Result<TokenStream> {
    if !item.generics.params.is_empty() {
        return Err(syn::Error::new_spanned(
            item.generics,
            "`#[derive(AsRef)]` doesn't support generics",
        ));
    }

    let tokens = item
        .fields
        .iter()
        .enumerate()
        .map(|(idx, field)| expand_field(&item.ident, idx, field))
        .collect();

    Ok(tokens)
}

fn expand_field(state: &Ident, idx: usize, field: &Field) -> TokenStream {
    let FieldAttrs { skip, wrap } = match parse_attrs("as_ref", &field.attrs) {
        Ok(attrs) => attrs,
        Err(err) => return err.into_compile_error(),
    };

    if skip.is_some() {
        return TokenStream::default();
    }

    let field_ty = &field.ty;
    let span = field.ty.span();

    let body = if let Some(field_ident) = &field.ident {
        quote_spanned! {span=> &self.#field_ident }
    } else {
        let idx = syn::Index {
            index: idx as _,
            span: field.span(),
        };
        quote_spanned! {span=> &self.#idx }
    };

    if wrap.is_some() {
        return match extract_type_from_arc(field_ty) {
            Some(field_ty) => {
                quote_spanned! {span=>
                    #[allow(clippy::needless_borrow)]
                    impl<T> ::std::convert::AsRef<T> for #state
                        where #field_ty: ::std::convert::AsRef<T>
                    {
                        fn as_ref(&self) -> &T {
                            use ::core::ops::Deref;
                            #body.deref().as_ref()
                        }
                    }
                }
            }
            None => syn::Error::new_spanned(
                field.ty.clone(),
                "`#[as_ref(wrap)]` is only supported for Arc types",
            )
            .into_compile_error(),
        };
    }

    quote_spanned! {span=>
        impl ::std::convert::AsRef<#field_ty> for #state {
            fn as_ref(&self) -> &#field_ty {
                #body
            }
        }
    }
}

mod kw {
    syn::custom_keyword!(skip);
    syn::custom_keyword!(wrap);
}

#[derive(Default)]
pub(super) struct FieldAttrs {
    pub(super) skip: Option<kw::skip>,
    pub(super) wrap: Option<kw::wrap>,
}

impl Parse for FieldAttrs {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let mut skip = None;
        let mut wrap = None;

        while !input.is_empty() {
            let lh = input.lookahead1();
            if lh.peek(kw::skip) {
                skip = Some(input.parse()?);
            } else if lh.peek(kw::wrap) {
                wrap = Some(input.parse()?);
            } else {
                return Err(lh.error());
            }

            let _ = input.parse::<Token![,]>();
        }

        Ok(Self { skip, wrap })
    }
}

impl Combine for FieldAttrs {
    fn combine(mut self, other: Self) -> syn::Result<Self> {
        let Self { skip, wrap } = other;
        combine_unary_attribute(&mut self.skip, skip)?;
        combine_unary_attribute(&mut self.wrap, wrap)?;
        Ok(self)
    }
}

#[test]
fn ui() {
    crate::run_ui_tests("as_ref");
}