resrap_proc_macro 0.2.0

Macros for resrap.
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

use proc_macro2::*;
use syn::*;
use quote::*;
use syn::spanned::Spanned;

pub fn struct_helper(identifier: Ident, data_struct: DataStruct, is_padded: bool) -> proc_macro2::TokenStream {

	// `TokenStream` containing each fields parses
	let mut field_parses = TokenStream::default();

	// tokens for variables returned in final return statement
	let mut return_variables = TokenStream::default();
	
	// for naming tuple fields
	let mut n = 0;

	let whitespace_parse = match is_padded {

		true => quote!{ let _ = Option::<Vec::<Whitespace>>::parse(position); },
		
		false => quote!{}

	};

	field_parses.extend(whitespace_parse.clone());

	for field in data_struct.fields.clone() {

		// the identifier used in the `Parse` implementation depends on the struct style
		let field_identifier = match data_struct.fields {

			Fields::Named(..) => field.ident.clone().unwrap(),
			Fields::Unnamed(..) => Ident::new( &format!("field_{}", n) ,Span::call_site()),
			Fields::Unit => Ident::new( &n.to_string(),Span::call_site())
	
		};
		
		n += 1;
	
		let field_type = field.ty.clone();
		
		let field_maybe = 
			Ident::new(
				&format!("{}_maybe", field_identifier),
				proc_macro2::Span::call_site()
			);
			
		return_variables.extend(quote_spanned!{field.span()=>
		
			#field_identifier, 
		
		}.to_token_stream());

		field_parses.extend(quote_spanned!{field.span()=>

			let #field_maybe = #field_type::parse(position);

			if #field_maybe.is_err() {

				let cause = Some(Box::new(#field_maybe.unwrap_err()));

				let error = Error {
					
					identifier: stringify!(#identifier).to_string(),
					position: start_position,
					cause
				
				};

				return Err(error);

			}

			let #field_identifier = #field_maybe.unwrap();

			#whitespace_parse

		}.to_token_stream());

	}

	let return_value = match  data_struct.fields {

		Fields::Named(..) => quote!{ Self { #return_variables } },
		Fields::Unnamed(..) => quote!{ Self( #return_variables) },
		Fields::Unit => quote!{ Self }

	};
 
	let quoted = quote_spanned! {identifier.span()=>

		impl Parse for #identifier {

			fn parse(position: &mut Position) -> Result<Self> {

				let start_position = position.clone();

				#field_parses

				Ok(#return_value)

			}

		}

	};

	quoted

}