enum-tree-derive 0.1.0

Derive macros for the enum-tree crate
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

use proc_macro2::TokenStream;
use quote::ToTokens as _;
use syn::{DeriveInput, Ident, Path};

struct Edge
{
    parent:      TokenStream,
    into_parent: Path,
}

pub fn derive_into_ancestors(input: &DeriveInput) -> TokenStream
{
    let type_name = &input.ident;

    let mut edges: Vec<Edge> = Vec::new();

    for attr in &input.attrs {
        if !attr.path().is_ident("ancestors") {
            continue;
        }
        let result = attr.parse_nested_meta(|meta| {
            let parent = meta.path.segments[0].to_token_stream();
            edges.push(Edge {
                parent,
                into_parent: meta.path,
            });
            Ok(())
        });
        if let Err(e) = result {
            return e.to_compile_error();
        }
    }

    let mut expanded = TokenStream::new();

    for edge in edges {
        expanded.extend(generate_impl_for_edge(type_name, edge));
    }
    expanded
}

fn generate_impl_for_edge(type_name: &Ident, edge: Edge) -> TokenStream
{
    let ancestor = edge.parent;
    let conversion = edge.into_parent;

    quote::quote! {
        impl ::core::convert::From<#type_name> for #ancestor {
            fn from(child: #type_name) -> #ancestor {
                #conversion(::core::convert::Into::into(child))
            }
        }
    }
}