derailleur-derive 0.1.0

Derive macro implementations for Derailleur
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

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    Data, DeriveInput, Error, Field, Fields, Ident, LitInt, Result, Type,
    parse::{Parse, ParseStream},
};

pub(crate) fn expand_from_records(input: &DeriveInput) -> Result<TokenStream> {
    let Data::Struct(data) = &input.data else {
        Err(Error::new_spanned(
            input,
            "`FromRecords` may only be derived on structs.",
        ))?
    };

    let Fields::Named(fields) = &data.fields else {
        Err(Error::new_spanned(
            input,
            "`FromRecords` may only be derived on structs with named fields.",
        ))?
    };

    let fields = fields
        .named
        .iter()
        .map(FieldMetadata::parse)
        .map(Result::transpose)
        .flatten() // Skip fields without an attribute.
        .collect::<Result<Vec<_>>>()?;

    let cases = fields.iter().map(|field| {
        let FieldMetadata {
            name,
            number,
            is_vec,
        } = field;

        let assignment = if *is_vec {
            quote! {
                self.#name.push(Default::default());
                self.#name.last_mut().map(|r| r as _)
            }
        } else {
            quote! {
                Some(self.#name.insert(Default::default()))
            }
        };

        quote! { #number => { #assignment } }
    });

    let name = &input.ident;

    let expanded = quote! {
        impl FromRecords for #name {
            fn add_record(&mut self, id: u16) -> Option<&mut dyn FromRecord> {
                match id {
                    #(#cases)*
                    _ => None,
                }
            }
        }
    };

    Ok(expanded.into())
}

#[derive(Debug)]
struct FieldMetadata {
    name: Ident,
    number: LitInt,
    is_vec: bool,
}

impl FieldMetadata {
    fn parse(field: &Field) -> Result<Option<Self>> {
        let name = field.ident.clone().unwrap();

        let Some(attr) = field.attrs.iter().find(|a| a.path().is_ident("record")) else {
            return Ok(None);
        };

        let RecordAttribute { number } = attr.meta.require_list()?.parse_args()?;

        let Type::Path(path) = &field.ty else {
            Err(Error::new_spanned(
                &field.ty,
                "Field must have a type annotation.",
            ))?
        };

        let Some(segment) = path.path.segments.first() else {
            Err(Error::new_spanned(
                &path.path.segments,
                "Field must have an `Option<T>` or `Vec<T>` type.",
            ))?
        };

        let is_vec = if segment.ident == "Option" {
            false
        } else if segment.ident == "Vec" {
            true
        } else {
            Err(Error::new_spanned(
                &segment.ident,
                "Field must have an `Option<T>` or `Vec<T>` type.",
            ))?
        };

        Ok(Some(Self {
            name,
            number,
            is_vec,
        }))
    }
}

#[derive(Debug)]
struct RecordAttribute {
    number: LitInt,
}

impl Parse for RecordAttribute {
    fn parse(input: ParseStream) -> Result<Self> {
        let number = input.parse::<LitInt>()?;
        Ok(Self { number })
    }
}