fairyvoid-with 1.0.0

With literal
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

#![feature(proc_macro_diagnostic)]

use proc_macro::TokenStream;
use quote::{quote, ToTokens};
use syn::parse::{Parse, ParseStream, Result};
use syn::{parse_macro_input, Ident, Token, Expr};

struct With {
    fields: Vec<WithField>,
    over: Option<Expr>,
}

struct WithField {
    name: Ident,
    init: Option<Expr>,
}

impl Parse for With {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut fields = vec![];
        let mut over: Option<Expr> = None;
        let mut found_default = false;

        while !input.is_empty() {
            if input.peek(Token![..]) {
                input.parse::<Token![..]>()?;
                if !input.is_empty() {
                    over = Some(input.parse::<Expr>()?);
                }
                found_default = true;
                break;
            }
            let name = input.parse::<Ident>()?;
            let init: Option<Expr>;
            if input.peek(Token![:]) {
                input.parse::<Token![:]>()?;
                init = Some(input.parse::<Expr>()?);
            } else {
                init = None;
            }
            fields.push(WithField { name, init });

            if input.peek(Token![,]) {
                input.parse::<Token![,]>()?;
            } else {
                break;
            }
        }
        if !found_default {
            if !fields.is_empty() {
                input.parse::<Token![,]>()?;
            }
            input.parse::<Token![..]>()?;
        }
        Ok(With { fields, over })
    }
}

/// Initializes a structure without specifying its name.
/// 
/// # Syntax
/// 
/// ```
/// with! {
///     field_1: value,
///     field_2,
///     .. // ..Default::default()
/// }
///
///
/// with! {
///     field_1: value,
///     field_2,
///     ..base
/// }
/// ```
#[proc_macro]
pub fn with(input: TokenStream) -> TokenStream {
    let With { fields, over } = parse_macro_input!(input as With);

    let mut expanded_fields = proc_macro2::TokenStream::new();

    for WithField { name, init } in fields {
        if let Some(init) = init {
            expanded_fields.extend::<proc_macro2::TokenStream>(quote! {
                _with_obj_1.#name = #init;
            }.try_into().unwrap());
        } else {
            expanded_fields.extend::<proc_macro2::TokenStream>(quote! {
                _with_obj_1.#name = #name;
            }.try_into().unwrap());
        }
    }

    let expanded_over = over.map(|over| over.into_token_stream()).unwrap_or(quote! {::std::default::Default::default()});

    let mut expanded = TokenStream::new();

    expanded.extend::<TokenStream>(quote! {
        {
            let mut _with_obj_1 = #expanded_over;
            if false {
                _with_obj_1
            } else {
                #expanded_fields
                _with_obj_1
            }
        }
    }.try_into().unwrap());

    expanded
}