upgrade to syn 2.0

panicbit · panicbit · commit fcb508802767 · 2024-01-22T00:11:33.000+01:00
diff --git a/custom_debug_derive/Cargo.toml b/custom_debug_derive/Cargo.toml
@@ -12,8 +12,9 @@ edition = "2021"
 proc-macro = true
 
 [dependencies]
-synstructure = "0.12.3"
-proc-macro2 = "1.0.6"
-syn = "1.0.11"
-quote = "1.0.23"
-itertools = "0.10.5"
+synstructure = "0.13.0"
+proc-macro2 = "1.0.76"
+syn = "2.0.48"
+quote = "1.0.35"
+itertools = "0.12.0"
+darling = "0.20.3"
diff --git a/custom_debug_derive/src/field_attributes.rs b/custom_debug_derive/src/field_attributes.rs
@@ -0,0 +1,92 @@
+use std::cell::OnceCell;
+
+use darling::util::Flag;
+use darling::FromMeta;
+use syn::ExprPath;
+
+#[derive(Default)]
+pub struct FieldAttributes {
+    pub skip: bool,
+    pub debug_format: DebugFormat,
+}
+
+impl FieldAttributes {
+    fn new(internal: InternalFieldAttributes) -> darling::Result<Self> {
+        let skip = internal.skip.is_present();
+        let debug_format = OnceCell::new();
+
+        if let Some(format) = internal.format {
+            debug_format
+                .set(DebugFormat::Format(format))
+                .map_err(|_| conflicting_format_options_error())?;
+        }
+
+        if let Some(with) = internal.with {
+            debug_format
+                .set(DebugFormat::With(with))
+                .map_err(|_| conflicting_format_options_error())?;
+        }
+
+        let debug_format = debug_format.into_inner().unwrap_or(DebugFormat::Default);
+
+        Ok(Self { skip, debug_format })
+    }
+
+    pub fn try_combine(self, other: Self) -> darling::Result<Self> {
+        let skip = self.skip || other.skip;
+        let debug_format = self.debug_format.try_combine(other.debug_format)?;
+
+        Ok(Self { skip, debug_format })
+    }
+}
+
+impl FromMeta for FieldAttributes {
+    fn from_nested_meta(item: &darling::ast::NestedMeta) -> darling::Result<Self> {
+        InternalFieldAttributes::from_nested_meta(item).and_then(FieldAttributes::new)
+    }
+
+    fn from_meta(item: &syn::Meta) -> darling::Result<Self> {
+        InternalFieldAttributes::from_meta(item).and_then(FieldAttributes::new)
+    }
+
+    fn from_none() -> Option<Self> {
+        InternalFieldAttributes::from_none().and_then(|attrs| FieldAttributes::new(attrs).ok())
+    }
+
+    fn from_word() -> darling::Result<Self> {
+        InternalFieldAttributes::from_word().and_then(FieldAttributes::new)
+    }
+
+    fn from_list(items: &[darling::ast::NestedMeta]) -> darling::Result<Self> {
+        InternalFieldAttributes::from_list(items).and_then(FieldAttributes::new)
+    }
+}
+
+#[derive(FromMeta, Debug, PartialEq, Eq, Default)]
+pub enum DebugFormat {
+    #[default]
+    Default,
+    Format(String),
+    With(ExprPath),
+}
+
+impl DebugFormat {
+    fn try_combine(self, other: Self) -> darling::Result<Self> {
+        match (&self, &other) {
+            (DebugFormat::Default, _) => Ok(other),
+            (_, DebugFormat::Default) => Ok(self),
+            _ => Err(conflicting_format_options_error()),
+        }
+    }
+}
+
+#[derive(FromMeta)]
+struct InternalFieldAttributes {
+    skip: Flag,
+    format: Option<String>,
+    with: Option<ExprPath>,
+}
+
+fn conflicting_format_options_error() -> darling::Error {
+    darling::Error::custom("Conflicting format options")
+}
diff --git a/custom_debug_derive/src/lib.rs b/custom_debug_derive/src/lib.rs
@@ -1,14 +1,17 @@
+use darling::FromMeta;
 use itertools::Itertools;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::spanned::Spanned;
-use syn::{parse_str, Fields, Ident, Lit, Meta, NestedMeta, Path, Result};
+use syn::{parse_str, Fields, Ident, Lit, Meta, Path, Result};
 use synstructure::{decl_derive, AddBounds, BindingInfo, Structure, VariantInfo};
 
+use crate::field_attributes::{DebugFormat, FieldAttributes};
 use crate::filter_ext::RetainExt;
 use crate::macros::{bail, error};
 use crate::result_into_stream_ext::ResultIntoStreamExt;
 
+mod field_attributes;
 mod filter_ext;
 mod macros;
 mod result_into_stream_ext;
@@ -37,24 +40,10 @@ fn custom_debug_derive(mut structure: Structure) -> Result<TokenStream> {
 }
 
 fn filter_out_skipped_fields(structure: &mut Structure) -> Result<()> {
-    let skip_ident: Ident = parse_str("skip").unwrap();
-
     structure.try_retain(|binding| {
-        for meta in get_custom_debug_metas(binding) {
-            let meta = meta?;
-
-            if let NestedMeta::Meta(Meta::Path(ref path)) = meta {
-                if path
-                    .get_ident()
-                    .map(|ident| ident == &skip_ident)
-                    .unwrap_or(false)
-                {
-                    return Ok(false);
-                }
-            }
-        }
+        let field_attributes = parse_field_attributes(binding)?;
 
-        Ok(true)
+        Ok(!field_attributes.skip)
     })?;
 
     Ok(())
@@ -82,20 +71,8 @@ fn generate_match_arm_body(variant: &VariantInfo) -> Result<TokenStream> {
 }
 
 fn generate_debug_builder_call(binding: &BindingInfo) -> Result<TokenStream> {
-    let mut format = None;
-
-    for meta in get_custom_debug_metas(binding) {
-        let meta = meta?;
-
-        match meta {
-            NestedMeta::Meta(Meta::NameValue(nv)) => {
-                format = Some(generate_name_value_builder_call(binding, nv)?)
-            }
-            _ => bail!(meta.span(), "Unsupported attribute"),
-        }
-    }
-
-    let format = format.unwrap_or_else(|| quote! { #binding });
+    let field_attributes = parse_field_attributes(binding)?;
+    let format = generate_debug_impl(binding, &field_attributes.debug_format);
 
     let debug_builder_call =
         if let Some(ref name) = binding.ast().ident.as_ref().map(<_>::to_string) {
@@ -111,70 +88,44 @@ fn generate_debug_builder_call(binding: &BindingInfo) -> Result<TokenStream> {
     Ok(debug_builder_call)
 }
 
-fn generate_name_value_builder_call(
-    binding: &BindingInfo,
-    nv: syn::MetaNameValue,
-) -> Result<TokenStream> {
-    let key_span = nv.path.span();
-    let value_span = nv.lit.span();
-    let value = nv.lit;
-    let ident = nv
-        .path
-        .get_ident()
-        .map(Ident::to_string)
-        .ok_or_else(|| error!(key_span, "Unsupported attribute"))?;
-
-    match &*ident {
-        "format" => Ok(quote! { &format_args!(#value, #binding) }),
-        "with" => match value {
-            Lit::Str(fun) => {
-                let fun = fun
-                    .parse::<Path>()
-                    .map_err(|_| error!(fun.span(), "Invalid path to function"))?;
-
-                Ok(quote! {
-                    {
-                        struct DebugWith<'a, T: 'a> {
-                            data: &'a T,
-                            fmt: fn(&T, &mut ::core::fmt::Formatter) -> ::core::fmt::Result,
-                        }
-
-                        impl<'a, T: 'a> ::core::fmt::Debug for DebugWith<'a, T> {
-                            fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-                                (self.fmt)(self.data, fmt)
-                            }
-                        }
-
-                        &DebugWith {
-                            data: #binding,
-                            fmt: #fun,
-                        }
+fn generate_debug_impl(binding: &BindingInfo, debug_format: &DebugFormat) -> TokenStream {
+    match debug_format {
+        DebugFormat::Default => quote! { #binding },
+        DebugFormat::Format(format) => quote! { &format_args!(#format, #binding) },
+        DebugFormat::With(with) => quote! {
+            {
+                struct DebugWith<'a, T: 'a> {
+                    data: &'a T,
+                    fmt: fn(&T, &mut ::core::fmt::Formatter) -> ::core::fmt::Result,
+                }
+
+                impl<'a, T: 'a> ::core::fmt::Debug for DebugWith<'a, T> {
+                    fn fmt(&self, fmt: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                        (self.fmt)(self.data, fmt)
                     }
-                })
+                }
+
+                &DebugWith {
+                    data: #binding,
+                    fmt: #with,
+                }
             }
-            _ => bail!(value_span, "Invalid `with` value"),
         },
-        _ => bail!(key_span, "Unsupported attribute"),
     }
 }
 
-fn get_custom_debug_metas<'a>(
-    binding: &BindingInfo<'a>,
-) -> impl Iterator<Item = Result<NestedMeta>> + 'a {
-    let debug_attr = parse_str::<Path>("debug").unwrap();
+fn parse_field_attributes(binding: &BindingInfo<'_>) -> Result<FieldAttributes> {
+    let mut combined_field_attributes = FieldAttributes::default();
 
-    binding
-        .ast()
-        .attrs
-        .iter()
-        .filter(move |attr| attr.path == debug_attr)
-        .map(|attr| {
-            let meta = attr.parse_meta()?;
+    for attr in &binding.ast().attrs {
+        if !attr.path().is_ident("debug") {
+            continue;
+        }
 
-            match meta {
-                Meta::List(list) => Ok(list.nested),
-                _ => bail!(meta.span(), "Unsupported attribute style, use `debug(…)`"),
-            }
-        })
-        .flatten_ok()
+        let field_attributes = FieldAttributes::from_meta(&attr.meta)?;
+
+        combined_field_attributes = combined_field_attributes.try_combine(field_attributes)?;
+    }
+
+    Ok(combined_field_attributes)
 }
