buffalo_macro 0.1.0

Serialization library for 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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use quote::quote;
use std::convert::TryInto;
use syn::spanned::Spanned;

pub type PointerType = u64;
pub const DEFAULT_ENUM_DISCRIMINANT_TYPE: EnumDiscriminantType = EnumDiscriminantType::U8;

pub struct EnumAttributes {
	pub size: EnumSize,
	pub discriminant_type: Option<EnumDiscriminantType>,
	pub value_size: Option<PointerType>,
}

pub enum EnumSize {
	Dynamic,
	Static,
}

pub enum EnumDiscriminantType {
	U8,
	U16,
}

impl EnumDiscriminantType {
	pub fn value(&self, value: u64) -> EnumDiscriminantValue {
		match self {
			EnumDiscriminantType::U8 => EnumDiscriminantValue::U8(value.try_into().unwrap()),
			EnumDiscriminantType::U16 => EnumDiscriminantValue::U16(value.try_into().unwrap()),
		}
	}
}

impl quote::ToTokens for EnumDiscriminantType {
	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
		let code = match self {
			EnumDiscriminantType::U8 => quote! { u8 },
			EnumDiscriminantType::U16 => quote! { u16 },
		};
		code.to_tokens(tokens);
	}
}

pub enum EnumDiscriminantValue {
	U8(u8),
	U16(u16),
}

impl quote::ToTokens for EnumDiscriminantValue {
	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
		let code = match self {
			EnumDiscriminantValue::U8(value) => quote! { #value },
			EnumDiscriminantValue::U16(value) => quote! { #value },
		};
		code.to_tokens(tokens);
	}
}

pub fn enum_attributes(input: &syn::DeriveInput) -> syn::Result<EnumAttributes> {
	let attr = input
		.attrs
		.iter()
		.find(|attr| attr.path.is_ident("buffalo"))
		.ok_or_else(|| syn::Error::new(input.span(), "buffalo attribute is required"))?;
	let meta = attr.parse_meta()?;
	let list = match meta {
		syn::Meta::List(list) => list,
		_ => {
			return Err(syn::Error::new_spanned(
				attr,
				"buffalo attribute must contain a list",
			))
		}
	};
	let mut size = None;
	let mut discriminant_type = None;
	let mut value_size = None;
	for item in list.nested.iter() {
		match item {
			syn::NestedMeta::Meta(syn::Meta::NameValue(item)) if item.path.is_ident("size") => {
				size = match &item.lit {
					syn::Lit::Str(value) if value.value() == "dynamic" => Some(EnumSize::Dynamic),
					syn::Lit::Str(value) if value.value() == "static" => Some(EnumSize::Static),
					_ => {
						return Err(syn::Error::new_spanned(
							&item,
							"value for attribute \"size\" must be \"dynamic\" or \"static\"",
						))
					}
				};
			}
			syn::NestedMeta::Meta(syn::Meta::NameValue(item))
				if item.path.is_ident("discriminant_size") =>
			{
				let value = if let syn::Lit::Int(value) = &item.lit {
					Some(value)
				} else {
					None
				};
				let value = value.ok_or_else(|| {
					syn::Error::new_spanned(
						&item,
						"value for attribute \"discriminant_size\" must be an integer",
					)
				})?;
				let value = value.base10_parse().map_err(|_| {
					syn::Error::new_spanned(
						&item,
						"value for attribute \"discriminant_size\" must be an integer",
					)
				})?;
				let value = match value {
					1 => EnumDiscriminantType::U8,
					2 => EnumDiscriminantType::U16,
					_ => {
						return Err(syn::Error::new_spanned(
							&item,
							"value for attribute \"discriminant_size\" must be 1 or 2",
						))
					}
				};
				discriminant_type = Some(value);
			}
			syn::NestedMeta::Meta(syn::Meta::NameValue(item))
				if item.path.is_ident("value_size") =>
			{
				let value = if let syn::Lit::Int(value) = &item.lit {
					Some(value)
				} else {
					None
				};
				let value = value.ok_or_else(|| {
					syn::Error::new_spanned(
						&item,
						"value for attribute \"value_size\" must be an integer",
					)
				})?;
				let value = value.base10_parse().map_err(|_| {
					syn::Error::new_spanned(
						&item,
						"value for attribute \"value_size\" must be an integer",
					)
				})?;
				value_size = Some(value);
			}
			_ => return Err(syn::Error::new_spanned(&item, "unknown attribute")),
		}
	}
	let size = size
		.ok_or_else(|| syn::Error::new_spanned(&list.nested, "\"size\" attribute is required"))?;
	Ok(EnumAttributes {
		size,
		discriminant_type,
		value_size,
	})
}