bauer-macros 0.5.0

Macro implementation for the `bauer` crate. This should only be accessed through the `bauer` 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

use proc_macro2::Span;
use syn::{
    AttrStyle, Ident, Meta, Token, braced, bracketed, parenthesized,
    parse::{ParseBuffer, ParseStream},
    parse_quote_spanned,
    spanned::Spanned,
    token::{Brace, Paren},
};

// from https://docs.rs/syn/latest/src/syn/attr.rs.html#681-689
fn single_parse_outer(input: ParseStream) -> syn::Result<syn::Attribute> {
    let content;
    Ok(syn::Attribute {
        pound_token: input.parse()?,
        style: AttrStyle::Outer,
        bracket_token: bracketed!(content in input),
        meta: content.parse()?,
    })
}

/// Parse a list of (optionally comma separated) attributes
pub fn parse_attributes(input: ParseStream, into: &mut Vec<syn::Attribute>) -> syn::Result<()> {
    // NOTE: can't use Punctuated here as there doesn't seem to be any way to
    // construct one with an optional separator
    while !input.is_empty() {
        let attr = single_parse_outer(input)?;
        into.push(attr);

        if input.is_empty() {
            break;
        }

        let la = input.lookahead1();
        if la.peek(Token![,]) {
            let _: Token![,] = input.parse()?;
        } else if la.peek(Token![#]) {
            continue;
        } else {
            return Err(la.error());
        }
    }
    Ok(())
}

/// Parse a list of (optionally comma separated) doc fields
pub fn parse_docs(
    input: ParseStream,
    doc_span: Span,
    into: &mut Vec<syn::Attribute>,
) -> syn::Result<()> {
    while !input.is_empty() {
        let la = input.lookahead1();

        let attr = if la.peek(Ident) {
            let meta: Meta = input.parse()?;
            parse_quote_spanned! {doc_span=>
                #[doc(#meta)]
            }
        } else if la.peek(Token![#]) {
            let attr = single_parse_outer(input)?;
            if !attr.meta.path().is_ident("doc") {
                return Err(syn::Error::new(
                    attr.meta.span(),
                    "Only `doc` attributes are supported here",
                ));
            }
            attr
        } else {
            return Err(la.error());
        };

        into.push(attr);

        if input.peek(Token![,]) {
            let _: Token![,] = input.parse()?;
        }
    }
    Ok(())
}

pub fn parethesised_or_braced<'a>(input: &'a ParseBuffer<'a>) -> syn::Result<ParseBuffer<'a>> {
    let inner;

    let la = input.lookahead1();
    if la.peek(Paren) {
        parenthesized!(inner in input);
    } else if la.peek(Brace) {
        braced!(inner in input);
    } else {
        return Err(la.error());
    }

    Ok(inner)
}