wrapper: allow to skip AsRef, AsMut, Borrow and BorrowMut implementations

Author: dr-orlovsky

src/lib.rs

@@ -648,6 +648,7 @@ pub fn derive_getters(input: TokenStream) -> TokenStream {
 /// * `amplify::Wrapper`
 /// * [`AsRef`]
 /// * [`core::borrow::Borrow`]
+/// You may skip `AsRef` and `Borrow` implementations with `#[wrapper(NoRefs)]`.
 ///
 /// You can implement additional derives, it they are implemented for the
 /// wrapped type, using `#[wrapper()]` proc macro:
@@ -775,6 +776,7 @@ pub fn derive_wrapper(input: TokenStream) -> TokenStream {
 /// * `amplify::WrapperMut`
 /// * [`AsMut`]
 /// * [`core::borrow::BorrowMut`]
+/// You may skip `AsMut` and `BorrowMut` implementations with `#[wrapper_mut(NoRefs)]`.
 ///
 /// You can implement additional derives, it they are implemented for the
 /// wrapped type, using `#[wrapper()]` proc macro:

src/wrapper.rs

@@ -24,8 +24,9 @@ use crate::util::get_amplify_crate;
 const NAME: &str = "wrapper";
 const EXAMPLE: &str = r#"#[wrapper(LowerHex, Add)]"#;
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug)]
 enum Wrapper {
+    NoRefs,
     // Formatting
     FromStr,
     Display,
@@ -38,6 +39,8 @@ enum Wrapper {
     UpperExp,
     // References
     Deref,
+    AsRef,
+    Borrow,
     BorrowSlice,
     // Indexes
     Index,
@@ -71,10 +74,13 @@ enum Wrapper {
     BitOps,
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug)]
 enum WrapperMut {
+    NoRefs,
     // References
     DerefMut,
+    AsMut,
+    BorrowMut,
     BorrowSliceMut,
     // Indexes
     IndexMut,
@@ -103,16 +109,28 @@ enum WrapperMut {
     BitAssign,
 }
 
-pub trait FromPath: Sized + Copy {
+pub trait FromPath: Sized + Copy + Ord {
     const IDENT: &'static str;
     const DERIVE: &'static str;
+    const NO_REFS: Self;
+    fn default_set() -> Vec<Self>;
+    fn is_not_ref(&self) -> bool;
     fn from_path(path: &Path) -> Result<Option<Self>>;
     fn populate(self, list: &mut Vec<Self>);
 }
 
 impl FromPath for Wrapper {
     const IDENT: &'static str = "wrapper";
     const DERIVE: &'static str = "Wrapper";
+    const NO_REFS: Self = Self::NoRefs;
+
+    fn default_set() -> Vec<Self> {
+        vec![Wrapper::AsRef, Wrapper::Borrow]
+    }
+
+    fn is_not_ref(&self) -> bool {
+        *self != Wrapper::AsRef && *self != Wrapper::Borrow
+    }
 
     fn from_path(path: &Path) -> Result<Option<Self>> {
         path.segments.first().map_or(
@@ -128,7 +146,10 @@ impl FromPath for Wrapper {
                     "UpperHex" => Some(Wrapper::UpperHex),
                     "LowerExp" => Some(Wrapper::LowerExp),
                     "UpperExp" => Some(Wrapper::UpperExp),
+                    "NoRefs" => Some(Wrapper::NoRefs),
+                    "AsRef" => Some(Wrapper::AsRef),
                     "Deref" => Some(Wrapper::Deref),
+                    "Borrow" => Some(Wrapper::Borrow),
                     "BorrowSlice" => Some(Wrapper::BorrowSlice),
                     "Index" => Some(Wrapper::Index),
                     "IndexRange" => Some(Wrapper::IndexRange),
@@ -339,6 +360,26 @@ impl Wrapper {
                     }
                 }
             },
+            Wrapper::AsRef => quote! {
+                #[automatically_derived]
+                impl #impl_generics ::core::convert::AsRef<<#ident_name #impl_generics as #amplify_crate::Wrapper>::Inner> for #ident_name #ty_generics #where_clause {
+                    #[inline]
+                    fn as_ref(&self) -> &<Self as #amplify_crate::Wrapper>::Inner {
+                        use #amplify_crate::Wrapper;
+                        Wrapper::as_inner(self)
+                    }
+                }
+            },
+            Wrapper::Borrow => quote! {
+                #[automatically_derived]
+                impl #impl_generics ::core::borrow::Borrow<<#ident_name #impl_generics as #amplify_crate::Wrapper>::Inner> for #ident_name #ty_generics #where_clause {
+                    #[inline]
+                    fn borrow(&self) -> &<Self as #amplify_crate::Wrapper>::Inner {
+                        use #amplify_crate::Wrapper;
+                        Wrapper::as_inner(self)
+                    }
+                }
+            },
             Wrapper::BorrowSlice => quote! {
                 #[automatically_derived]
                 impl #impl_generics ::core::borrow::Borrow<[u8]> for #ident_name #ty_generics #where_clause
@@ -623,13 +664,25 @@ impl Wrapper {
 impl FromPath for WrapperMut {
     const IDENT: &'static str = "wrapper_mut";
     const DERIVE: &'static str = "WrapperMut";
+    const NO_REFS: Self = Self::NoRefs;
+
+    fn default_set() -> Vec<Self> {
+        vec![WrapperMut::AsMut, WrapperMut::BorrowMut]
+    }
+
+    fn is_not_ref(&self) -> bool {
+        *self != WrapperMut::AsMut && *self != WrapperMut::BorrowMut
+    }
 
     fn from_path(path: &Path) -> Result<Option<Self>> {
         path.segments.first().map_or(
             Err(attr_err!(path.span(), NAME, "must contain at least one identifier", EXAMPLE)),
             |segment| {
                 Ok(match segment.ident.to_string().as_str() {
+                    "NoRefs" => Some(WrapperMut::NoRefs),
                     "DerefMut" => Some(WrapperMut::DerefMut),
+                    "AsMut" => Some(WrapperMut::AsMut),
+                    "BorrowMut" => Some(WrapperMut::BorrowMut),
                     "BorrowSliceMut" => Some(WrapperMut::BorrowSliceMut),
                     "IndexMut" => Some(WrapperMut::IndexMut),
                     "IndexRangeMut" => Some(WrapperMut::IndexRangeMut),
@@ -715,6 +768,26 @@ impl WrapperMut {
                     }
                 }
             },
+            WrapperMut::AsMut => quote! {
+                #[automatically_derived]
+                impl #impl_generics ::core::convert::AsMut<<#ident_name #impl_generics as #amplify_crate::Wrapper>::Inner> for #ident_name #ty_generics #where_clause {
+                    #[inline]
+                    fn as_mut(&mut self) -> &mut <Self as #amplify_crate::Wrapper>::Inner {
+                        use #amplify_crate::WrapperMut;
+                        WrapperMut::as_inner_mut(self)
+                    }
+                }
+            },
+            WrapperMut::BorrowMut => quote! {
+                #[automatically_derived]
+                impl #impl_generics ::core::borrow::BorrowMut<<#ident_name #impl_generics as #amplify_crate::Wrapper>::Inner> for #ident_name #ty_generics #where_clause {
+                    #[inline]
+                    fn borrow_mut(&mut self) -> &mut <Self as #amplify_crate::Wrapper>::Inner {
+                        use #amplify_crate::WrapperMut;
+                        WrapperMut::as_inner_mut(self)
+                    }
+                }
+            },
             WrapperMut::BorrowSliceMut => quote! {
                 #[automatically_derived]
                 impl #impl_generics ::core::borrow::BorrowMut<[u8]> for #ident_name #ty_generics #where_clause
@@ -976,24 +1049,6 @@ pub(crate) fn inner(input: DeriveInput) -> Result<TokenStream2> {
             }
         }
 
-        #[automatically_derived]
-        impl #impl_generics ::core::convert::AsRef<<#ident_name #impl_generics as #amplify_crate::Wrapper>::Inner> for #ident_name #ty_generics #where_clause {
-            #[inline]
-            fn as_ref(&self) -> &<Self as #amplify_crate::Wrapper>::Inner {
-                use #amplify_crate::Wrapper;
-                Wrapper::as_inner(self)
-            }
-        }
-
-        #[automatically_derived]
-        impl #impl_generics ::core::borrow::Borrow<<#ident_name #impl_generics as #amplify_crate::Wrapper>::Inner> for #ident_name #ty_generics #where_clause {
-            #[inline]
-            fn borrow(&self) -> &<Self as #amplify_crate::Wrapper>::Inner {
-                use #amplify_crate::Wrapper;
-                Wrapper::as_inner(self)
-            }
-        }
-
         #( #wrapper_derive )*
     })
 }
@@ -1017,24 +1072,6 @@ pub(crate) fn inner_mut(input: DeriveInput) -> Result<TokenStream2> {
             }
         }
 
-        #[automatically_derived]
-        impl #impl_generics ::core::convert::AsMut<<#ident_name #impl_generics as #amplify_crate::Wrapper>::Inner> for #ident_name #ty_generics #where_clause {
-            #[inline]
-            fn as_mut(&mut self) -> &mut <Self as #amplify_crate::Wrapper>::Inner {
-                use #amplify_crate::WrapperMut;
-                WrapperMut::as_inner_mut(self)
-            }
-        }
-
-        #[automatically_derived]
-        impl #impl_generics ::core::borrow::BorrowMut<<#ident_name #impl_generics as #amplify_crate::Wrapper>::Inner> for #ident_name #ty_generics #where_clause {
-            #[inline]
-            fn borrow_mut(&mut self) -> &mut <Self as #amplify_crate::Wrapper>::Inner {
-                use #amplify_crate::WrapperMut;
-                WrapperMut::as_inner_mut(self)
-            }
-        }
-
         #( #wrapper_derive )*
     })
 }
@@ -1120,7 +1157,7 @@ fn get_params(input: &DeriveInput) -> Result<(TokenStream2, Type)> {
 }
 
 fn get_wrappers<T: FromPath>(input: &DeriveInput) -> Result<Vec<T>> {
-    let mut wrappers = vec![];
+    let mut wrappers = T::default_set();
     const WRAPPER_DERIVE_ERR: &str = "Wrapper attributes must be in a form of type list";
     for attr in input
         .attrs
@@ -1146,5 +1183,8 @@ fn get_wrappers<T: FromPath>(input: &DeriveInput) -> Result<Vec<T>> {
             _ => return Err(attr_err!(attr, WRAPPER_DERIVE_ERR)),
         }
     }
+    if wrappers.contains(&T::NO_REFS) {
+        wrappers = wrappers.into_iter().filter(T::is_not_ref).collect();
+    }
     Ok(wrappers)
 }