Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/dat_map/src/dat.rs

9.7 KiB, 1 run

created by r1870400018:75859, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1//! `#[derive(ToDat, FromDat)]`: every field goes through its own `ToDat`/`FromDat`, so any field
2//! type that has them (a derived type, `Option`, `Vec`, a tuple, a `BTreeMap`) nests. No `Default`.
3//!
4//! The encoding, which is stable:
5//! - a struct with named fields is a `Dat::Map` from each field name to its value,
6//! - a tuple struct is a `Dat::List` of its fields in order, a unit struct `Dat::Empty`,
7//! - an enum variant is a one-entry `Dat::Map` from the variant name to its payload, which is
8//! `Dat::Empty`, a `Dat::List` or a `Dat::Map` by the same rules.
9//!
10//! Decoding refuses a missing field, an unknown field, a list of the wrong length and an unknown
11//! variant, naming the type, the variant and the field.
12
13use proc_macro2::TokenStream;
14use quote::{
15 format_ident,
16 quote,
17};
18use syn::{
19 DeriveInput,
20 Fields,
21};
22
23
24enum Side {
25 To,
26 From,
27}
28
29/// Wraps an `Outcome` expression in an early return, since generated code is held to the same
30/// rule as written code: no `?`.
31fn tri(expr: TokenStream) -> TokenStream {
32 quote! {
33 match #expr {
34 ::core::result::Result::Ok(v) => v,
35 ::core::result::Result::Err(e) => return ::core::result::Result::Err(e),
36 }
37 }
38}
39
40fn key_of(ident: &syn::Ident) -> String {
41 let s = ident.to_string();
42 match s.strip_prefix("r#") {
43 Some(rest) => rest.to_string(),
44 None => s,
45 }
46}
47
48fn bounded(ast: &DeriveInput, side: Side) -> syn::Generics {
49 let mut generics = ast.generics.clone();
50 let params: Vec<syn::Ident> = generics.type_params().map(|p| p.ident.clone()).collect();
51 if !params.is_empty() {
52 let clause = generics.make_where_clause();
53 for p in params {
54 let pred: syn::WherePredicate = match side {
55 Side::To => syn::parse_quote! { #p: ::oxedyne_fe2o3_jdat::conv::ToDat },
56 Side::From => syn::parse_quote! { #p: ::oxedyne_fe2o3_jdat::conv::FromDat },
57 };
58 clause.predicates.push(pred);
59 }
60 }
61 generics
62}
63
64/// The encoding of a set of fields already bound to `bindings`.
65fn encode_fields(fields: &Fields, bindings: &[syn::Ident], ty: &str) -> TokenStream {
66 match fields {
67 Fields::Named(named) => {
68 let mut puts = Vec::new();
69 for (f, b) in named.named.iter().zip(bindings) {
70 let key = match &f.ident {
71 Some(ident) => key_of(ident),
72 None => String::new(),
73 };
74 let enc = tri(quote! { __d::enc(#b, #ty, #key) });
75 puts.push(quote! { __d::put(&mut __m, #key, #enc); });
76 }
77 quote! {{
78 let mut __m = __d::DaticleMap::new();
79 #(#puts)*
80 __d::Dat::Map(__m)
81 }}
82 },
83 Fields::Unnamed(_) => {
84 let mut items = Vec::new();
85 for (i, b) in bindings.iter().enumerate() {
86 let at = i.to_string();
87 items.push(tri(quote! { __d::enc(#b, #ty, #at) }));
88 }
89 quote! { __d::Dat::List(::std::vec![#(#items),*]) }
90 },
91 Fields::Unit => quote! { __d::Dat::Empty },
92 }
93}
94
95/// Decodes `__p` into the fields, then builds `ctor`.
96fn decode_fields(fields: &Fields, ctor: TokenStream, ty: &str) -> TokenStream {
97 match fields {
98 Fields::Named(named) => {
99 let mut lets = Vec::new();
100 let mut inits = Vec::new();
101 for (i, f) in named.named.iter().enumerate() {
102 let ident = match &f.ident {
103 Some(ident) => ident.clone(),
104 None => format_ident!("__f{}", i),
105 };
106 let key = key_of(&ident);
107 let v = format_ident!("__v{}", i);
108 let get = tri(quote! { __d::field(&mut __m, #ty, #key) });
109 lets.push(quote! { let #v = #get; });
110 inits.push(quote! { #ident: #v });
111 }
112 let take = tri(quote! { __d::take_map(__p, #ty) });
113 let done = tri(quote! { __d::done(__m, #ty) });
114 quote! {{
115 let mut __m = #take;
116 #(#lets)*
117 #done;
118 ::core::result::Result::Ok(#ctor { #(#inits),* })
119 }}
120 },
121 Fields::Unnamed(unnamed) => {
122 let n = unnamed.unnamed.len();
123 let mut lets = Vec::new();
124 let mut vs = Vec::new();
125 for i in 0..n {
126 let v = format_ident!("__v{}", i);
127 let get = tri(quote! { __d::item(&mut __it, #ty, #i) });
128 lets.push(quote! { let #v = #get; });
129 vs.push(v);
130 }
131 let take = tri(quote! { __d::take_list(__p, #ty, #n) });
132 quote! {{
133 let mut __it = #take;
134 #(#lets)*
135 ::core::result::Result::Ok(#ctor ( #(#vs),* ))
136 }}
137 },
138 Fields::Unit => {
139 let take = tri(quote! { __d::take_unit(__p, #ty) });
140 quote! {{
141 #take;
142 ::core::result::Result::Ok(#ctor)
143 }}
144 },
145 }
146}
147
148/// The bindings a pattern over `fields` introduces, and the pattern itself.
149fn pattern(fields: &Fields, path: TokenStream) -> (TokenStream, Vec<syn::Ident>) {
150 match fields {
151 Fields::Named(named) => {
152 let mut binds = Vec::new();
153 let mut pats = Vec::new();
154 for (i, f) in named.named.iter().enumerate() {
155 let b = format_ident!("__b{}", i);
156 if let Some(ident) = &f.ident {
157 pats.push(quote! { #ident: #b });
158 }
159 binds.push(b);
160 }
161 (quote! { #path { #(#pats),* } }, binds)
162 },
163 Fields::Unnamed(unnamed) => {
164 let binds: Vec<syn::Ident> =
165 (0..unnamed.unnamed.len()).map(|i| format_ident!("__b{}", i)).collect();
166 (quote! { #path ( #(#binds),* ) }, binds)
167 },
168 Fields::Unit => (path, Vec::new()),
169 }
170}
171
172pub fn derive_to_dat(ast: DeriveInput) -> TokenStream {
173 let name = &ast.ident;
174 let tname = name.to_string();
175 let generics = bounded(&ast, Side::To);
176 let (impl_g, ty_g, where_c) = generics.split_for_impl();
177 let body = match &ast.data {
178 syn::Data::Struct(st) => {
179 let (pat, binds) = pattern(&st.fields, quote! { Self });
180 let enc = encode_fields(&st.fields, &binds, &tname);
181 match &st.fields {
182 Fields::Unit => quote! { ::core::result::Result::Ok(#enc) },
183 _ => quote! {
184 let #pat = self;
185 ::core::result::Result::Ok(#enc)
186 },
187 }
188 },
189 syn::Data::Enum(en) => {
190 let mut arms = Vec::new();
191 for v in &en.variants {
192 let vident = &v.ident;
193 let vname = key_of(vident);
194 let vty = format!("{}::{}", tname, vname);
195 let (pat, binds) = pattern(&v.fields, quote! { Self::#vident });
196 let enc = encode_fields(&v.fields, &binds, &vty);
197 arms.push(quote! { #pat => ::core::result::Result::Ok(__d::variant(#vname, #enc)), });
198 }
199 if arms.is_empty() {
200 quote! { match *self {} }
201 } else {
202 quote! {
203 match self {
204 #(#arms)*
205 }
206 }
207 }
208 },
209 syn::Data::Union(_) => return syn::Error::new_spanned(
210 name, "ToDat cannot be derived for a union.").to_compile_error(),
211 };
212 quote! {
213 impl #impl_g ::oxedyne_fe2o3_jdat::conv::ToDat for #name #ty_g #where_c {
214 #[allow(unused_variables, unused_imports)]
215 fn to_dat(&self) -> ::oxedyne_fe2o3_jdat::derive::Outcome<::oxedyne_fe2o3_jdat::Dat> {
216 use ::oxedyne_fe2o3_jdat::derive as __d;
217 #body
218 }
219 }
220 }
221}
222
223pub fn derive_from_dat(ast: DeriveInput) -> TokenStream {
224 let name = &ast.ident;
225 let tname = name.to_string();
226 let generics = bounded(&ast, Side::From);
227 let (impl_g, ty_g, where_c) = generics.split_for_impl();
228 let body = match &ast.data {
229 syn::Data::Struct(st) => {
230 let dec = decode_fields(&st.fields, quote! { Self }, &tname);
231 quote! {
232 let __p = dat;
233 #dec
234 }
235 },
236 syn::Data::Enum(en) => {
237 let mut arms = Vec::new();
238 for v in &en.variants {
239 let vident = &v.ident;
240 let vname = key_of(vident);
241 let vty = format!("{}::{}", tname, vname);
242 let dec = decode_fields(&v.fields, quote! { Self::#vident }, &vty);
243 arms.push(quote! { #vname => #dec, });
244 }
245 let take = tri(quote! { __d::take_variant(dat, #tname) });
246 quote! {
247 let (__n, __p) = #take;
248 match __n.as_str() {
249 #(#arms)*
250 _ => ::core::result::Result::Err(__d::unknown_variant(#tname, &__n)),
251 }
252 }
253 },
254 syn::Data::Union(_) => return syn::Error::new_spanned(
255 name, "FromDat cannot be derived for a union.").to_compile_error(),
256 };
257 quote! {
258 impl #impl_g ::oxedyne_fe2o3_jdat::conv::FromDat for #name #ty_g #where_c {
259 #[allow(unused_variables, unused_mut, unused_imports)]
260 fn from_dat(dat: ::oxedyne_fe2o3_jdat::Dat)
261 -> ::oxedyne_fe2o3_jdat::derive::Outcome<Self>
262 {
263 use ::oxedyne_fe2o3_jdat::derive as __d;
264 #body
265 }
266 }
267 }
268}