Merge pull request #60 from jbr/fix-deref-mut

fix: Do not auto-deref Rc, Cow, or Arc

Author: jbr

docs.md

@@ -164,17 +164,17 @@ dereferenced as such. So for example, a field that contains a `String` will retu
 or `&mut str` from `get_mut` by default. This behavior can be opted out of, at any configuration
 level.
 
-| Owned Type | Borrowed Type |
-|------------|---------------|
-| `String`   | `&str`        |
-| `OsString  | `&OsStr`      |
-| `Vec<T>`   | `&[T]`        |
-| `Box<T>`   | `&T`          |
-| `Arc<T>`   | `&T`          |
-| `Rc<T>`    | `&T`          |
-| `PathBuf`  | `&Path`       |
-| `Cow<T>`   | `&T`          |
-| `[T; N]`   | `&[T]`        |
+| Owned Type | Borrowed Type | DerefMut
+|------------|---------------|------
+| `String`   | `&str`        | yes
+| `OsString  | `&OsStr`      | yes
+| `Vec<T>`   | `&[T]`        | yes
+| `Box<T>`   | `&T`          | yes
+| `Arc<T>`   | `&T`          | no
+| `Rc<T>`    | `&T`          | no
+| `PathBuf`  | `&Path`       | yes
+| `Cow<T>`   | `&T`          | no
+| `[T; N]`   | `&[T]`        | yes
 
 ### Common copy types are detected by default
 

src/deref_handling.rs

@@ -2,7 +2,9 @@ use std::borrow::Cow;
 
 use syn::{GenericArgument, Path, PathArguments, Type, TypeArray, TypePath, parse_quote};
 
-pub(crate) fn auto_deref(ty: &Type) -> Option<Cow<'_, Type>> {
+use crate::Method;
+
+pub(crate) fn auto_deref(ty: &Type, method: Method) -> Option<Cow<'_, Type>> {
     let segments = match ty {
         Type::Path(TypePath {
             path: Path { segments, .. },
@@ -39,7 +41,7 @@ pub(crate) fn auto_deref(ty: &Type) -> Option<Cow<'_, Type>> {
         return Some(Cow::Owned(parse_quote!([#inner_type])));
     }
 
-    if last_segment.ident == "Box" || last_segment.ident == "Arc" || last_segment.ident == "Rc" {
+    if last_segment.ident == "Box" {
         let PathArguments::AngleBracketed(ref bracketed_args) = last_segment.arguments else {
             return None;
         };
@@ -51,20 +53,34 @@ pub(crate) fn auto_deref(ty: &Type) -> Option<Cow<'_, Type>> {
         return Some(Cow::Borrowed(inner_type));
     }
 
-    if last_segment.ident == "Cow" {
-        let PathArguments::AngleBracketed(ref bracketed_args) = last_segment.arguments else {
-            return None;
-        };
+    if method == Method::Get {
+        if last_segment.ident == "Arc" || last_segment.ident == "Rc" {
+            let PathArguments::AngleBracketed(ref bracketed_args) = last_segment.arguments else {
+                return None;
+            };
 
-        let Some(GenericArgument::Lifetime(_)) = bracketed_args.args.first() else {
-            return None;
-        };
+            let Some(GenericArgument::Type(inner_type)) = bracketed_args.args.first() else {
+                return None;
+            };
 
-        let Some(GenericArgument::Type(t)) = bracketed_args.args.get(1) else {
-            return None;
-        };
+            return Some(Cow::Borrowed(inner_type));
+        }
+
+        if last_segment.ident == "Cow" {
+            let PathArguments::AngleBracketed(ref bracketed_args) = last_segment.arguments else {
+                return None;
+            };
 
-        return Some(Cow::Borrowed(t));
+            let Some(GenericArgument::Lifetime(_)) = bracketed_args.args.first() else {
+                return None;
+            };
+
+            let Some(GenericArgument::Type(t)) = bracketed_args.args.get(1) else {
+                return None;
+            };
+
+            return Some(Cow::Borrowed(t));
+        }
     }
 
     None

src/query.rs

@@ -257,7 +257,7 @@ impl<'a> Query<'a> {
 
     fn auto_deref(&self, ty: &'a Type) -> Option<Cow<'a, Type>> {
         if self.common_setting(|x| x.auto_deref) {
-            auto_deref(ty)
+            auto_deref(ty, *self.method)
         } else {
             None
         }

tests/expand/15-auto-deref.expanded.rs

@@ -39,20 +39,20 @@ impl<'a, T> Detection<'a, T> {
     pub fn arc(&self) -> &T {
         &*self.arc
     }
-    pub fn arc_mut(&mut self) -> &mut T {
-        &mut *self.arc
+    pub fn arc_mut(&mut self) -> &mut std::sync::Arc<T> {
+        &mut self.arc
     }
     pub fn rc(&self) -> &T {
         &*self.rc
     }
-    pub fn rc_mut(&mut self) -> &mut T {
-        &mut *self.rc
+    pub fn rc_mut(&mut self) -> &mut std::rc::Rc<T> {
+        &mut self.rc
     }
     pub fn cow(&self) -> &T {
         &*self.cow
     }
-    pub fn cow_mut(&mut self) -> &mut T {
-        &mut *self.cow
+    pub fn cow_mut(&mut self) -> &mut Cow<'a, T> {
+        &mut self.cow
     }
     pub fn path(&self) -> &std::path::Path {
         &*self.path
@@ -218,20 +218,20 @@ impl<'a, T> OptionDeref<'a, T> {
     pub fn arc(&self) -> Option<&T> {
         self.arc.as_deref()
     }
-    pub fn arc_mut(&mut self) -> Option<&mut T> {
-        self.arc.as_deref_mut()
+    pub fn arc_mut(&mut self) -> Option<&mut std::sync::Arc<T>> {
+        self.arc.as_mut()
     }
     pub fn rc(&self) -> Option<&T> {
         self.rc.as_deref()
     }
-    pub fn rc_mut(&mut self) -> Option<&mut T> {
-        self.rc.as_deref_mut()
+    pub fn rc_mut(&mut self) -> Option<&mut std::rc::Rc<T>> {
+        self.rc.as_mut()
     }
     pub fn cow(&self) -> Option<&T> {
         self.cow.as_deref()
     }
-    pub fn cow_mut(&mut self) -> Option<&mut T> {
-        self.cow.as_deref_mut()
+    pub fn cow_mut(&mut self) -> Option<&mut Cow<'a, T>> {
+        self.cow.as_mut()
     }
     pub fn path(&self) -> Option<&std::path::Path> {
         self.path.as_deref()