Merge pull request #61 from jbr/improved-pipeline

fix: address poorly-handled nested type detection

Author: jbr

Cargo.toml

@@ -13,7 +13,7 @@ keywords = ["macros"]
 categories = ["development-tools"]
 
 [features]
-debug = ["syn/extra-traits"]
+debug = []
 
 [lib]
 proc-macro = true
@@ -22,7 +22,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0.95"
 quote = "1.0.40"
-syn = { version = "2.0.101", features = ["full"] }
+syn = { version = "2.0.101", features = ["full", "extra-traits"] }
 
 [dev-dependencies]
 macrotest = { version = "1.1.0" }

docs.md

@@ -280,9 +280,9 @@ impl User {
     pub fn name(&self) -> &str {
         &*self.name
     }
-    ///Borrows the user's age, if set
-    pub fn age(&self) -> Option<&u8> {
-        self.age.as_ref()
+    ///Returns a copy of the user's age, if set
+    pub fn age(&self) -> Option<u8> {
+        self.age
     }
     ///Borrows favorite color, if set
     pub fn favorite_color(&self) -> Option<&str> {

src/copy_detection.rs

@@ -1,6 +1,8 @@
 use syn::{Path, Type, TypePath, TypeReference};
 
-pub(crate) fn enable_copy_for_type(ty: &Type) -> bool {
+use crate::Method;
+
+pub(crate) fn enable_copy_for_type(ty: &Type, method: Method) -> bool {
     match ty {
         Type::Path(TypePath {
             path: Path { segments, .. },
@@ -32,6 +34,11 @@ pub(crate) fn enable_copy_for_type(ty: &Type) -> bool {
             mutability: None, ..
         }) => true,
 
+        Type::Reference(TypeReference {
+            mutability: Some(_),
+            ..
+        }) => method == Method::GetMut,
+
         _ => false,
     }
 }

src/deref_handling.rs

@@ -1,32 +1,51 @@
-use std::borrow::Cow;
-
-use syn::{GenericArgument, Path, PathArguments, Type, TypeArray, TypePath, parse_quote};
+use proc_macro2::Span;
+use syn::{
+    GenericArgument, Path, PathArguments, Type, TypeArray, TypePath, TypeReference,
+    parse_quote_spanned,
+};
 
 use crate::Method;
 
-pub(crate) fn auto_deref(ty: &Type, method: Method) -> Option<Cow<'_, Type>> {
+pub(crate) fn auto_deref(ty: &Type, method: Method, span: Span) -> Option<(Type, usize)> {
+    let mut ty = ty.clone();
+    let mut count = 0;
+
+    while let Some(next_ty) = auto_deref_inner(&ty, method, span) {
+        ty = next_ty;
+        count += 1;
+    }
+
+    if count > 0 { Some((ty, count)) } else { None }
+}
+
+pub(crate) fn auto_deref_inner(ty: &Type, method: Method, span: Span) -> Option<Type> {
     let segments = match ty {
+        Type::Reference(TypeReference {
+            mutability: Some(_),
+            elem,
+            ..
+        }) => return Some(*elem.clone()),
         Type::Path(TypePath {
             path: Path { segments, .. },
             ..
         }) => segments,
-        Type::Array(TypeArray { elem, .. }) => return Some(Cow::Owned(parse_quote!([#elem]))),
+        Type::Array(TypeArray { elem, .. }) => return Some(parse_quote_spanned!(span => [#elem])),
         _ => {
             return None;
         }
     };
 
     let last_segment = segments.last()?;
     if last_segment.ident == "String" {
-        return Some(Cow::Owned(parse_quote!(str)));
+        return Some(parse_quote_spanned!(span => str));
     }
 
     if last_segment.ident == "PathBuf" {
-        return Some(Cow::Owned(parse_quote!(std::path::Path)));
+        return Some(parse_quote_spanned!(span => std::path::Path));
     }
 
     if last_segment.ident == "OsString" {
-        return Some(Cow::Owned(parse_quote!(std::ffi::OsStr)));
+        return Some(parse_quote_spanned!(span => std::ffi::OsStr));
     }
 
     if last_segment.ident == "Vec" {
@@ -38,7 +57,7 @@ pub(crate) fn auto_deref(ty: &Type, method: Method) -> Option<Cow<'_, Type>> {
             return None;
         };
 
-        return Some(Cow::Owned(parse_quote!([#inner_type])));
+        return Some(parse_quote_spanned!(span => [#inner_type]));
     }
 
     if last_segment.ident == "Box" {
@@ -50,7 +69,7 @@ pub(crate) fn auto_deref(ty: &Type, method: Method) -> Option<Cow<'_, Type>> {
             return None;
         };
 
-        return Some(Cow::Borrowed(inner_type));
+        return Some(inner_type.clone());
     }
 
     if method == Method::Get {
@@ -63,7 +82,7 @@ pub(crate) fn auto_deref(ty: &Type, method: Method) -> Option<Cow<'_, Type>> {
                 return None;
             };
 
-            return Some(Cow::Borrowed(inner_type));
+            return Some(inner_type.clone());
         }
 
         if last_segment.ident == "Cow" {
@@ -79,7 +98,7 @@ pub(crate) fn auto_deref(ty: &Type, method: Method) -> Option<Cow<'_, Type>> {
                 return None;
             };
 
-            return Some(Cow::Borrowed(t));
+            return Some(t.clone());
         }
     }
 

src/option_handling.rs

@@ -21,12 +21,17 @@ pub(crate) fn extract_option_type(ty: &Type) -> Option<&Type> {
     let Some(GenericArgument::Type(inner_type)) = bracketed_args.args.first() else {
         return None;
     };
-    Some(strip_ref(inner_type))
+
+    Some(inner_type)
 }
 
 pub(crate) fn strip_ref(ty: &Type) -> &Type {
+    ref_inner(ty).unwrap_or(ty)
+}
+
+pub(crate) fn ref_inner(ty: &Type) -> Option<&Type> {
     match ty {
-        Type::Reference(TypeReference { elem, .. }) => elem,
-        _ => ty,
+        Type::Reference(TypeReference { elem, .. }) => Some(elem),
+        _ => None,
     }
 }