From f14a34b94e110b691acdb20dcdc1d609a0bd725d Mon Sep 17 00:00:00 2001 From: Yuki Sireneva Date: Wed, 3 Apr 2024 18:04:51 +0300 Subject: [PATCH] Formatting, clippy, new rust, more correct reexports, TESTS PASSING on nightly (Mar 27) --- src/bound.rs | 2 +- src/de.rs | 31 +++++++++++++++--------------- src/lib.rs | 5 ++--- src/ser.rs | 48 +++++++++++++++++++++++----------------------- tests/serialize.rs | 4 ++-- 5 files changed, 44 insertions(+), 46 deletions(-) diff --git a/src/bound.rs b/src/bound.rs index bd1856f..a48305c 100644 --- a/src/bound.rs +++ b/src/bound.rs @@ -31,7 +31,7 @@ pub fn with_lifetime_bound(generics: &Generics, lifetime: &str) -> Generics { .collect(); Generics { - params: params, + params, ..generics.clone() } } diff --git a/src/de.rs b/src/de.rs index f00a0c4..efaa565 100644 --- a/src/de.rs +++ b/src/de.rs @@ -9,7 +9,7 @@ use syn::{ }; pub fn derive(input: &DeriveInput, enumeration: &DataEnum) -> Result { - 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 { - 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(::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(::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>, } diff --git a/src/lib.rs b/src/lib.rs index fb1c819..316b4af 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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() } diff --git a/src/ser.rs b/src/ser.rs index ae221de..b80c905 100644 --- a/src/ser.rs +++ b/src/ser.rs @@ -8,7 +8,7 @@ use syn::{parse_quote, DataEnum, DeriveInput, Fields, FieldsNamed, FieldsUnnamed pub fn derive(input: &DeriveInput, enumeration: &DataEnum) -> Result { 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 { - 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 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, &dyn miniserde::Serialize)> { + fn next(&mut self) -> std::prelude::v1::Option<(std::borrow::Cow, &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, &dyn miniserde::Serialize)> { + fn next(&mut self) -> std::prelude::v1::Option<(#cow, &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, &dyn miniserde::Serialize)> { + fn next(&mut self) -> std::prelude::v1::Option<(#cow, &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, &dyn miniserde::Serialize)> { + fn next(&mut self) -> std::prelude::v1::Option<(std::borrow::Cow, &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)) } } diff --git a/tests/serialize.rs b/tests/serialize.rs index a163f0e..6058d80 100644 --- a/tests/serialize.rs +++ b/tests/serialize.rs @@ -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")]