worktable_macros 0.9.0

Proc-macro companion crate for worktable: the worktable! macro and its derives. Formerly published as worktable_codegen.
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

use proc_macro2::TokenTree;
use syn::spanned::Spanned;

use crate::common::parser::Parser;

impl Parser {
    /// Parses ':' from [`proc_macro2::TokenStream`].
    pub fn parse_colon(&mut self) -> syn::Result<()> {
        let iter = &mut self.input_iter;

        let colon = iter
            .next()
            .ok_or(syn::Error::new(self.input.span(), "Expected token."))?;
        if let TokenTree::Punct(colon) = colon {
            if colon.as_char() != ':' {
                return Err(syn::Error::new(
                    colon.span(),
                    format!("Expected `:` found: `{}`", colon.as_char()),
                ));
            }

            Ok(())
        } else {
            Err(syn::Error::new(colon.span(), "Expected `:`."))
        }
    }

    /// Tries to parse ',' from [`TokenStream`] without calling `next` on wrong token.
    pub fn try_parse_comma(&mut self) -> syn::Result<()> {
        let iter = &mut self.input_iter;

        if let Some(colon) = iter.peek()
            && comma(colon).is_ok()
        {
            iter.next();
        }

        Ok(())
    }

    /// Parses '=>' from token stream.
    pub fn parse_fat_arrow(&mut self) -> syn::Result<()> {
        let iter = &mut self.input_iter;

        let first = iter
            .next()
            .ok_or(syn::Error::new(self.input.span(), "Expected token."))?;
        if let TokenTree::Punct(p) = first {
            if p.as_char() == '=' {
                // next should be '>'
                let second = iter
                    .next()
                    .ok_or(syn::Error::new(self.input.span(), "Expected '>' after '='"))?;
                if let TokenTree::Punct(p2) = second {
                    if p2.as_char() == '>' {
                        return Ok(());
                    }
                    return Err(syn::Error::new(
                        p2.span(),
                        format!("Expected '>' found: '{}'", p2.as_char()),
                    ));
                }
                return Err(syn::Error::new(second.span(), "Expected '>'"));
            }
            return Err(syn::Error::new(
                p.span(),
                format!("Expected '=' found: '{}'", p.as_char()),
            ));
        }
        Err(syn::Error::new(first.span(), "Expected '=>'"))
    }
}

fn comma(tt: &TokenTree) -> syn::Result<()> {
    if let TokenTree::Punct(colon) = tt {
        if colon.as_char() != ',' {
            return Err(syn::Error::new(
                colon.span(),
                format!("Expected `,` found: `{}`", colon.as_char()),
            ));
        }

        Ok(())
    } else {
        Err(syn::Error::new(tt.span(), "Expected `,`."))
    }
}