multihash-derive-impl 0.1.2

Internal proc-macro crate for the MultihashDigest derive
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

use proc_macro2::Span;
use proc_macro_crate::{crate_name, FoundCrate};
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::Error;

pub fn use_crate(name: &str) -> Result<syn::Ident, Error> {
    match crate_name(name) {
        Ok(FoundCrate::Name(krate)) => Ok(syn::Ident::new(&krate, Span::call_site())),
        Ok(FoundCrate::Itself) => Ok(syn::Ident::new("crate", Span::call_site())),
        Err(err) => Err(Error::new(Span::call_site(), err)),
    }
}

#[derive(Debug)]
pub(crate) struct Attrs<A> {
    // The information is part of the parsed AST, we preserve it even if it isn't used yet.
    #[allow(dead_code)]
    pub ident: syn::Ident,
    // The information is part of the parsed AST, we preserve it even if it isn't used yet.
    #[allow(dead_code)]
    pub paren: syn::token::Paren,
    pub attrs: Punctuated<A, syn::token::Comma>,
}

impl<A: Parse> Parse for Attrs<A> {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        // Maybe check if ident == "mh"
        let ident = input.parse()?;
        let content;
        let paren = syn::parenthesized!(content in input);
        let attrs = content.parse_terminated(A::parse, syn::token::Comma)?;
        Ok(Self {
            ident,
            paren,
            attrs,
        })
    }
}

#[derive(Debug)]
pub(crate) struct Attr<K, V> {
    // The information is part of the parsed AST, we preserve it even if it isn't used yet.
    #[allow(dead_code)]
    pub key: K,
    // The information is part of the parsed AST, we preserve it even if it isn't used yet.
    #[allow(dead_code)]
    pub eq: syn::token::Eq,
    pub value: V,
}

impl<K: Parse, V: Parse> Parse for Attr<K, V> {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(Self {
            key: input.parse()?,
            eq: input.parse()?,
            value: input.parse()?,
        })
    }
}