default_kwargs 0.1.0

The macro wich enables you to use default and keyword arguments in Rust
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use quote::{quote, TokenStreamExt};
use syn::{parse, punctuated};

use crate::utils::{capitalize, outer_attributes};

pub struct KeywordFn {
    pub attrs: Vec<syn::Attribute>,
    pub func: Box<syn::ExprPath>,
    pub paren_token: syn::token::Paren,
    pub args: KeywordFnArgs,
}

impl parse::Parse for KeywordFn {
    fn parse(input: parse::ParseStream) -> syn::Result<Self> {
        let attrs: Vec<syn::Attribute> = input.call(syn::Attribute::parse_outer)?;
        let func: Box<syn::ExprPath> = input.parse()?;
        let content: parse::ParseBuffer;
        let paren_token: syn::token::Paren = syn::parenthesized!(content in input);
        Ok(Self {
            attrs,
            func,
            paren_token,
            args: content.parse()?,
        })
    }
}

impl quote::ToTokens for KeywordFn {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.append_all(outer_attributes(&self.attrs));
        let mut func_args_path = self.func.path.segments.clone();
        // At least one element in a path.
        let pair = func_args_path.pop().unwrap();
        let func_name = &pair.value().ident;
        func_args_path.push_value(syn::PathSegment {
            ident: quote::format_ident!("{}Args", capitalize(&mut func_name.to_string())),
            arguments: syn::PathArguments::None,
        });
        self.func.to_tokens(tokens);
        self.paren_token.surround(tokens, |tokens| {
            let positional = self.args.positional_args.pairs().map(|p| *p.value());
            let default_args = self.args.keyword_args.pairs().map(|p| {
                let KeywordArg {
                    pat: field_name,
                    value,
                    ..
                } = p.value();
                quote! { #field_name: #value }
            });
            let arguments = quote! {
                #(#positional,)*
                #[allow(clippy::needless_update)]
                #func_args_path {
                    #(#default_args,)*
                    ..#func_args_path::default()
                }
            };
            tokens.extend([arguments]);
        });
    }
}

pub struct KeywordFnArgs {
    pub positional_args: punctuated::Punctuated<syn::Expr, syn::Token![,]>,
    pub keyword_args: punctuated::Punctuated<KeywordArg, syn::Token![,]>,
}

impl parse::Parse for KeywordFnArgs {
    fn parse(input: parse::ParseStream) -> syn::Result<Self> {
        let mut positional_args = punctuated::Punctuated::new();
        let mut keyword_args = punctuated::Punctuated::new();

        loop {
            if input.is_empty() {
                break;
            }

            if input.peek2(syn::Token![=]) {
                break;
            }

            let arg: syn::Expr = input.parse()?;
            positional_args.push_value(arg);

            if input.is_empty() {
                break;
            }

            let comma: syn::Token![,] = input.parse()?;
            positional_args.push_punct(comma);
        }

        while !input.is_empty() {
            let kw_arg: KeywordArg = input.parse()?;
            keyword_args.push_value(kw_arg);

            if input.is_empty() {
                break;
            }

            let comma: syn::Token![,] = input.parse()?;
            keyword_args.push_punct(comma);
        }

        Ok(Self {
            positional_args,
            keyword_args,
        })
    }
}

pub struct KeywordArg {
    pub pat: Box<syn::Pat>,
    pub eq_token: syn::Token![=],
    pub value: syn::Expr,
}

impl parse::Parse for KeywordArg {
    fn parse(input: parse::ParseStream) -> syn::Result<Self> {
        Ok(Self {
            pat: input.parse()?,
            eq_token: input.parse()?,
            value: input.parse()?,
        })
    }
}

impl quote::ToTokens for KeywordArg {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        self.pat.to_tokens(tokens);
        self.eq_token.to_tokens(tokens);
        self.value.to_tokens(tokens);
    }
}