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 | |
| 13 | use proc_macro2::TokenStream; |
| 14 | use quote::{ |
| 15 | format_ident, |
| 16 | quote, |
| 17 | }; |
| 18 | use syn::{ |
| 19 | DeriveInput, |
| 20 | Fields, |
| 21 | }; |
| 22 | |
| 23 | |
| 24 | enum 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 `?`. |
| 31 | fn 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 | |
| 40 | fn 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 | |
| 48 | fn 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`. |
| 65 | fn 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`. |
| 96 | fn 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. |
| 149 | fn 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 | |
| 172 | pub 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 | |
| 223 | pub 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 | } |