Jika/miniserde_enum
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Formatting, clippy, new rust, more correct reexports, TESTS PASSING on nightly (Mar 27)

Browse Source
This commit is contained in:
Yuki Sireneva
2024-04-03 18:04:51 +03:00
parent 21418730e1
commit f14a34b94e
5 changed files with 44 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/bound.rs
View File

@@ -31,7 +31,7 @@ pub fn with_lifetime_bound(generics: &Generics, lifetime: &str) -> Generics {
.collect();
Generics {
params: params,
params,
..generics.clone()
}
}

31
src/de.rs
View File

@@ -9,7 +9,7 @@ use syn::{
};
pub fn derive(input: &DeriveInput, enumeration: &DataEnum) -> Result<TokenStream> {
let tag_type = attr::tag_type(&input.attrs, &enumeration)?;
let tag_type = attr::tag_type(&input.attrs, enumeration)?;
match &tag_type {
TagType::External => deserialize_external(input, enumeration),
TagType::Adjacent { tag, content } => {
@@ -34,14 +34,10 @@ struct EnumVariants {
impl EnumVariants {
fn new(ident: &Ident, enumeration: &DataEnum) -> Result<EnumVariants> {
let (unit_variants, struct_variants): (Vec<_>, Vec<_>) =
enumeration.variants.iter().partition(|v| {
if let Fields::Unit = &v.fields {
true
} else {
false
}
});
let (unit_variants, struct_variants): (Vec<_>, Vec<_>) = enumeration
.variants
.iter()
.partition(|v| matches!(&v.fields, Fields::Unit));
let struct_variant_names = struct_variants
.iter()
.cloned()
@@ -100,10 +96,11 @@ pub fn deserialize_internal(
..
} = EnumVariants::new(ident, enumeration)?;
let ex = quote!(miniserde::export);
let ex = quote!(std::prelude::v1);
Ok(quote! {
const _: () = {
#[repr(transparent)]
struct __Visitor {
__out: #ex::Option<#ident>,
}
@@ -141,7 +138,7 @@ pub fn deserialize_internal(
#(#structs)*
impl<'a> miniserde::de::Map for __State<'a> {
fn key(&mut self, k: &#ex::str) -> miniserde::Result<&mut dyn miniserde::de::Visitor> {
fn key(&mut self, k: &core::primitive::str) -> miniserde::Result<&mut dyn miniserde::de::Visitor> {
if k == #tag {
return Ok(<String as miniserde::Deserialize>::begin(&mut self.__tag));
}
@@ -196,10 +193,11 @@ pub fn deserialize_adjacent(
..
} = EnumVariants::new(ident, enumeration)?;
let ex = quote!(miniserde::export);
let ex = quote!(std::prelude::v1);
Ok(quote! {
const _: () = {
#[repr(transparent)]
struct __Visitor {
__out: #ex::Option<#ident>,
}
@@ -235,7 +233,7 @@ pub fn deserialize_adjacent(
#(#structs)*
impl<'a> miniserde::de::Map for __State<'a> {
fn key(&mut self, k: &#ex::str) -> miniserde::Result<&mut dyn miniserde::de::Visitor> {
fn key(&mut self, k: &core::primitive::str) -> miniserde::Result<&mut dyn miniserde::de::Visitor> {
match k {
#tag => Ok(<String as miniserde::Deserialize>::begin(&mut self.__tag)),
#content => {
@@ -289,7 +287,7 @@ pub fn deserialize_external(input: &DeriveInput, enumeration: &DataEnum) -> Resu
..
} = EnumVariants::new(ident, enumeration)?;
let ex = quote!(miniserde::export);
let ex = quote!(std::prelude::v1);
Ok(quote! {
const _: () = {
@@ -337,7 +335,7 @@ pub fn deserialize_external(input: &DeriveInput, enumeration: &DataEnum) -> Resu
#(#structs)*
impl #wrapper_impl_generics miniserde::de::Map for __State #wrapper_ty_generics #bounded_where_clause {
fn key(&mut self, k: &#ex::str) -> miniserde::Result<&mut dyn miniserde::de::Visitor> {
fn key(&mut self, k: &core::primitive::str) -> miniserde::Result<&mut dyn miniserde::de::Visitor> {
match k {
#(
#struct_variant_names => #ex::Ok(#struct_names::begin(&mut self.#struct_variant_idents)),
@@ -426,7 +424,7 @@ pub fn unnamed_fields_as_struct(
#(#field_idents: #field_types,)*
}
};
let ex = quote!(miniserde::export);
let ex = quote!(std::prelude::v1);
let de_impl = if fields.unnamed.len() == 1 {
let ty = field_types[0];
quote! {
@@ -439,6 +437,7 @@ pub fn unnamed_fields_as_struct(
} else {
let index = 0usize..;
quote! {
#[repr(transparent)]
struct __Visitor {
__out: #ex::Option<#ident>,
}

5
src/lib.rs
View File

@@ -5,7 +5,6 @@ mod bound;
mod de;
mod ser;
use std::convert::From;
use syn::{parse_macro_input, Data, DeriveInput, Error};
#[derive(Debug)]
@@ -27,7 +26,7 @@ pub fn derive_serialize(tokens: proc_macro::TokenStream) -> proc_macro::TokenStr
.into()
}
};
ser::derive(&input, &en)
ser::derive(&input, en)
.unwrap_or_else(|err| err.to_compile_error())
.into()
}
@@ -43,7 +42,7 @@ pub fn derive_deserialize(tokens: proc_macro::TokenStream) -> proc_macro::TokenS
.into()
}
};
de::derive(&input, &en)
de::derive(&input, en)
.unwrap_or_else(|err| err.to_compile_error())
.into()
}

48
src/ser.rs
View File

@@ -8,7 +8,7 @@ use syn::{parse_quote, DataEnum, DeriveInput, Fields, FieldsNamed, FieldsUnnamed
pub fn derive(input: &DeriveInput, enumeration: &DataEnum) -> Result<TokenStream> {
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let ident = &input.ident;
let tag_type = attr::tag_type(&input.attrs, &enumeration)?;
let tag_type = attr::tag_type(&input.attrs, enumeration)?;
let names = enumeration
.variants
.iter()
@@ -28,7 +28,7 @@ pub fn derive(input: &DeriveInput, enumeration: &DataEnum) -> Result<TokenStream
}
}
Fields::Named(fields) => {
let implementation = serialize_named(input, &fields, name, &tag_type)?;
let implementation = serialize_named(input, fields, name, &tag_type)?;
let field_ident = fields
.named
.iter()
@@ -75,27 +75,27 @@ fn serialize_unit(variant_name: &str, tag_type: &TagType) -> Result<TokenStream>
Ok(if let TagType::Internal(tag) = &tag_type {
quote! {
struct __Map {
state: miniserde::export::usize,
state: usize,
}
impl miniserde::ser::Map for __Map {
fn next(&mut self) -> miniserde::export::Option<(miniserde::export::Cow<miniserde::export::str>, &dyn miniserde::Serialize)> {
fn next(&mut self) -> std::prelude::v1::Option<(std::borrow::Cow<core::primitive::str>, &dyn miniserde::Serialize)> {
let __state = self.state;
self.state = __state + 1;
match __state {
0 => miniserde::export::Some((
miniserde::export::Cow::Borrowed(#tag),
0 => std::prelude::v1::Some((
std::borrow::Cow::Borrowed(#tag),
&#variant_name,
)),
_ => miniserde::export::None,
_ => std::prelude::v1::None,
}
}
}
miniserde::ser::Fragment::Map(miniserde::export::Box::new(__Map {state: 0}))
miniserde::ser::Fragment::Map(std::prelude::v1::Box::new(__Map {state: 0}))
}
} else {
quote! {miniserde::ser::Fragment::Str(miniserde::export::Cow::Borrowed(#variant_name))}
quote! {miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(#variant_name))}
})
}
@@ -125,8 +125,8 @@ fn serialize_named(
let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
let bound = parse_quote!(miniserde::Serialize);
let bounded_where_clause = bound::where_clause_with_bound(&input.generics, bound);
let cow = quote!(miniserde::export::Cow);
let some = quote!(miniserde::export::Some);
let cow = quote!(std::borrow::Cow);
let some = quote!(std::prelude::v1::Some);
if let TagType::External = tag_type {
Ok(quote! {
use miniserde::Serialize;
@@ -137,21 +137,21 @@ fn serialize_named(
struct __SuperMap #wrapper_impl_generics #where_clause {
data: __AsStruct #wrapper_ty_generics,
state: miniserde::export::usize,
state: usize,
}
impl #wrapper_impl_generics miniserde::ser::Map for __SuperMap #wrapper_ty_generics #bounded_where_clause {
fn next(&mut self) -> miniserde::export::Option<(#cow<miniserde::export::str>, &dyn miniserde::Serialize)> {
fn next(&mut self) -> std::prelude::v1::Option<(#cow<core::primitive::str>, &dyn miniserde::Serialize)> {
let __state = self.state;
self.state = __state + 1;
match __state {
0 => #some((#cow::Borrowed(#variant_name), &self.data)),
_ => miniserde::export::None,
_ => std::prelude::v1::None,
}
}
}
miniserde::ser::Fragment::Map(miniserde::export::Box::new(__SuperMap {
miniserde::ser::Fragment::Map(std::prelude::v1::Box::new(__SuperMap {
data: __AsStruct { #(#field_ident),* },
state: 0,
}))
@@ -169,11 +169,11 @@ fn serialize_named(
Ok(quote! {
struct __Map #wrapper_impl_generics {
#(#field_ident: &'__b #field_type),*,
state: miniserde::export::usize,
state: usize,
}
impl #wrapper_impl_generics miniserde::ser::Map for __Map #wrapper_ty_generics #where_clause {
fn next(&mut self) -> miniserde::export::Option<(#cow<miniserde::export::str>, &dyn miniserde::Serialize)> {
fn next(&mut self) -> std::prelude::v1::Option<(#cow<core::primitive::str>, &dyn miniserde::Serialize)> {
let __state = self.state;
self.state = __state + 1;
match __state {
@@ -184,12 +184,12 @@ fn serialize_named(
self.#field_ident,
))
})*,
_ => miniserde::export::None,
_ => std::prelude::v1::None,
}
}
}
miniserde::ser::Fragment::Map(miniserde::export::Box::new(__Map {
miniserde::ser::Fragment::Map(std::prelude::v1::Box::new(__Map {
#(#field_ident),*,
state: #start,
}))
@@ -216,14 +216,14 @@ fn serialize_unnamed(
let bound = parse_quote!(miniserde::Serialize);
let bounded_where_clause = bound::where_clause_with_bound(&input.generics, bound);
let index = 0usize..;
let ex = quote!(miniserde::export);
let ex = quote!(std::prelude::v1);
let seq = if field_ident.len() == 1 {
quote! { #(#field_ident.begin())* }
} else {
quote! {
struct __Seq #wrapper_impl_generics #where_clause {
#(#field_ident: &'__b #field_type),*,
state: miniserde::export::usize,
state: usize,
}
impl #wrapper_impl_generics miniserde::ser::Seq for __Seq #wrapper_ty_generics #bounded_where_clause {
@@ -260,12 +260,12 @@ fn serialize_unnamed(
}
impl #wrapper_impl_generics miniserde::ser::Map for __SuperMap #wrapper_ty_generics #bounded_where_clause {
fn next(&mut self) -> miniserde::export::Option<(#ex::Cow<miniserde::export::str>, &dyn miniserde::Serialize)> {
fn next(&mut self) -> std::prelude::v1::Option<(std::borrow::Cow<core::primitive::str>, &dyn miniserde::Serialize)> {
if self.state {
return miniserde::export::None;
return std::prelude::v1::None;
}
self.state = true;
#ex::Some((#ex::Cow::Borrowed(#variant_name), &self.data))
#ex::Some((std::borrow::Cow::Borrowed(#variant_name), &self.data))
}
}

4
tests/serialize.rs
View File

@@ -3,8 +3,8 @@ use miniserde_enum::Serialize_enum;
#[test]
fn test_internal() {
#[serde(tag = "type")]
#[derive(Serialize_enum)]
#[serde(tag = "type")]
enum Internal {
A,
#[serde(rename = "renamedB")]
@@ -41,8 +41,8 @@ fn test_external() {
#[test]
fn test_untagged() {
#[serde(untagged)]
#[derive(Serialize_enum)]
#[serde(untagged)]
enum Untagged {
A(i32),
#[serde(rename = "renamedB")]