Bugfix/double reference

impl/src/fmt/display.rs

@@ -11,6 +11,8 @@ use crate::utils::{attr::ParseMultiple as _, Spanning};
 
 use super::{trait_name_to_attribute_name, ContainerAttributes};
 
+const POINTER_TRAIT_NAME: &str = "Pointer";
+
 /// Expands a [`fmt::Display`]-like derive macro.
 ///
 /// Available macros:
@@ -94,8 +96,14 @@ fn expand_struct(
             .ident
             .clone()
             .map_or_else(|| syn::Member::Unnamed(i.into()), syn::Member::Named);
-        quote! {
-            let #var = &self.#member;
+        if let syn::Type::Reference(_) = f.ty {
+            quote! {
+                let #var = self.#member;
+            }
+        } else {
+            quote! {
+                let #var = &self.#member;
+            }
         }
     });
 
@@ -251,7 +259,7 @@ impl<'a> Expansion<'a> {
                 let trait_ident = self.trait_ident;
 
                 Ok(quote! {
-                    derive_more::core::fmt::#trait_ident::fmt(#ident, __derive_more_f)
+                    derive_more::core::fmt::#trait_ident::fmt(&#ident, __derive_more_f)
                 })
             }
             _ => Err(syn::Error::new(
@@ -265,6 +273,30 @@ impl<'a> Expansion<'a> {
         }
     }
 
+    /// Get the type to be bound by the trait to be derived.
+    /// For example, deriving `Display` for `Struct<E>(E)` requires the type `E`
+    /// to have the trait bound `Display`.
+    ///
+    /// For traits other than `Pointer`, all layers of `&` on the outside are
+    /// stripped because the trait's format function does the same.
+    fn get_bound_constrained_type<'b, 'c>(
+        &'c self,
+        input_type: &'b syn::Type,
+        trait_ident: &'b syn::Ident
+    ) -> &'b syn::Type {
+        let mut ty = input_type;
+        if !trait_ident.eq(POINTER_TRAIT_NAME) {
+            loop {
+                if let syn::Type::Reference(syn::TypeReference { elem, .. }) = ty {
+                    ty = elem;
+                } else {
+                    break;
+                }
+            }
+        }
+        ty
+    }
+
     /// Generates trait bounds for a struct or an enum variant.
     fn generate_bounds(&self) -> Vec<syn::WherePredicate> {
         let Some(fmt) = &self.attrs.fmt else {
@@ -273,7 +305,7 @@ impl<'a> Expansion<'a> {
                 .iter()
                 .next()
                 .map(|f| {
-                    let ty = &f.ty;
+                    let ty = self.get_bound_constrained_type(&f.ty, &self.trait_ident);
                     let trait_ident = &self.trait_ident;
                     vec![parse_quote! { #ty: derive_more::core::fmt::#trait_ident }]
                 })

tests/display.rs

@@ -680,6 +680,55 @@ mod structs {
             }
         }
     }
+
+    mod unnamed_pointer {
+        use super::*;
+        use std::fmt;
+
+        #[derive(Display)]
+        #[display("{_0:p}")]
+        struct UnnamedPointer<'a>(&'a u32);
+
+        #[derive(Display)]
+        #[display("{}", format!("{_0:p}"))]
+        struct UnnamedPointerWithFormat<'a>(&'a u32);
+
+        #[derive(Pointer)]
+        struct UnnamedPointerDerivePointer<'a, E>(&'a E);
+
+        #[test]
+        fn assert_no_double_reference() {
+            let i: u32 = line!();
+            assert_eq!(
+                format!("{}", UnnamedPointer(&i)),
+                format!("{:p}", &i)
+            );
+        }
+
+        #[test]
+        fn assert_no_double_reference_with_format() {
+            let i: u32 = line!();
+            assert_eq!(
+                format!("{}", UnnamedPointerWithFormat(&i)),
+                format!("{:p}", &i)
+            );
+        }
+
+        #[test]
+        fn assert_no_double_reference_deriving_pointer() {
+            let i: u32 = line!();
+            let j: &u32 = &i;
+            let k: &&u32 = &j;
+            assert_eq!(
+                format!("{:p}", UnnamedPointerDerivePointer(j)),
+                format!("{:p}", j)
+            );
+            assert_eq!(
+                format!("{:p}", UnnamedPointerDerivePointer(k)),
+                format!("{:p}", k)
+            );
+        }
+    }
 }
 
 mod enums {