abio_derive 0.1.1

Derive macros for the `abio` 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
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

#![allow(dead_code)]

use proc_macro2::{Span, TokenStream};
use quote::ToTokens;
use quote::{format_ident, quote};
use syn::{parse_macro_input, DeriveInput, Error, Result};

mod helpers;
use helpers::{Abi, BytesOf, Generate, Zeroable};

const ABIO_DEBUG: &str = "ABIO_DEBUG";

#[proc_macro_derive(Abi)]
pub fn derive_abi(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    derive_marker_trait_inner::<Abi>(input)
}

#[proc_macro_derive(BytesOf)]
pub fn derive_as_bytes(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    derive_marker_trait_inner::<BytesOf>(input)
}

#[proc_macro_derive(Zeroable)]
pub fn derive_zeroable(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    derive_marker_trait_inner::<Zeroable>(input)
}

fn derive_marker_trait_inner<G: Generate>(
    input: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    generate_trait_impl::<G>(input).unwrap_or_else(|e| e.into_compile_error()).into()
}

#[proc_macro_derive(Decode)]
pub fn derive_decode(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    // Parse the input tokens into a syntax tree
    let input = parse_macro_input!(input as DeriveInput);
    // Parse the input AST from the `Decode<T>` trait.
    let expanded = parse_decode_input(&input);

    // Return the generated implementation as tokens
    TokenStream::from(expanded).into()
}

fn inspect_input(tts: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let parsed = parse_macro_input!(tts as DeriveInput);
    println!("{parsed:#?}");
    proc_macro::TokenStream::from(parsed.to_token_stream())
}

fn parse_decode_input(input: &DeriveInput) -> proc_macro2::TokenStream {
    let name = format_ident!("{}", input.ident);
    quote! {
        #name
    }
}

fn derive_decode_trait(_input: &DeriveInput) -> TokenStream {
    unimplemented!()
}

fn generate_trait_impl<G: Generate>(mut input: DeriveInput) -> Result<proc_macro2::TokenStream> {
    // Enforce Abi to be implemented on all
    let trait_name = G::ident(&input);
    G::add_trait_marker(&mut input.generics, &trait_name);

    let name = &input.ident;

    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();

    G::check_attributes(&input.data, &input.attrs).map_err(|err| {
        eprintln!("{err:?}");
        Error::new(
            Span::call_site(),
            "Cannot implement this trait for this type due to invalid attribute values.",
        )
    })?;

    let assertions = match G::asserts(&input) {
        Ok(asserts) => asserts,
        Err(err) => err.into_compile_error().to_token_stream(),
    };

    let (trait_impl_extras, trait_impl) = G::trait_impl(&input)?;

    let impl_prefix = if G::is_unsafe(&input) {
        quote! {
            unsafe impl
        }
    } else {
        quote! {
            impl
        }
    };

    let implies_trait = if let Some(implies_trait) = G::fulfills_contract() {
        quote! {
            #impl_prefix #impl_generics #implies_trait for #name #ty_generics #where_clause {}
        }
    } else {
        quote! {}
    };

    let where_clause = if G::requires_where_clause() { where_clause } else { None };

    Ok(quote! {
      #assertions

      #trait_impl_extras

      #impl_prefix #impl_generics #trait_name for #name #ty_generics #where_clause {
        #trait_impl
      }

      #implies_trait
    })
}