Merge pull request #88 from JRRudy1/fields

Implemented delegation to fields

Author: Kobzol

.github/workflows/test.yml

@@ -26,6 +26,12 @@ jobs:
           override: true
           components: rustfmt, clippy
 
+      - name: Install cargo-expand
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: --locked --version 1.0.118 cargo-expand
+
       - name: Build
         uses: actions-rs/cargo@v1
         with:

Cargo.toml

@@ -25,3 +25,4 @@ proc-macro = true
 async-trait = "0.1.50"
 futures = "0.3.16"
 tokio = { version = "1.16.1", features = ["sync"] }
+macrotest = "1.0.12"

README.md

@@ -456,6 +456,58 @@ impl Enum {
 assert_eq!(Enum::A(A).get_toto(), <A as WithConst>::TOTO);
 ```
 
+### Delegate to fields
+```rust
+use delegate::delegate;
+
+struct Datum {
+    value: u32,
+    error: u32,
+}
+
+struct DatumWrapper(Datum);
+
+impl DatumWrapper {
+    delegate! {
+        to self.0 {
+            /// Get the value of a nested field with the same name
+            #[field]
+            fn value(&self) -> u32;
+
+            /// Get the value of a nested field with a different name
+            #[field(value)]
+            fn renamed_value(&self) -> u32;
+
+            /// Get shared reference to a nested field
+            #[field(&value)]
+            fn value_ref(&self) -> &u32;
+
+            /// Get mutable reference to a nested field
+            #[field(&mut value)]
+            fn value_ref_mut(&mut self) -> &mut u32;
+
+            /// Get mutable reference to a nested field with the same name
+            #[field(&)]
+            fn error(&self) -> &u32;
+        }
+    }
+}
+```
+
+## Development
+
+This project uses a standard test suite for quality control, as well as a set of
+"expansion" tests that utilize the `macrotest` crate to ensure the macro expands
+as expected. PRs implementing new features should add both standard and expansion
+tests where appropriate.
+
+To add an expansion test, place a Rust source file in the `tests/expand/` directory
+with methods demonstrating the new feature. Next, run `cargo test` to run the test
+suite and generate a `*.expanded.rs` file in the same directory. Next, carefully
+inspect the contents of the generated file to confirm that all methods expanded as
+expected. Finally, commit both files to the git repository. Future test suite runs
+will now include expanding the source file and comparing it to the expanded file.
+
 ## License
 
 Licensed under either of

src/attributes.rs

@@ -1,11 +1,11 @@
-use std::collections::VecDeque;
-
 use proc_macro2::{Delimiter, TokenStream, TokenTree};
 use quote::ToTokens;
+use std::collections::VecDeque;
+use std::ops::Not;
 use syn::parse::ParseStream;
-use syn::{Attribute, Error, Meta, Path, PathSegment, TypePath};
+use syn::{Attribute, Error, Meta, Path, PathSegment, Token, TypePath};
 
-struct CallMethodAttribute {
+pub struct CallMethodAttribute {
     name: syn::Ident,
 }
 
@@ -17,6 +17,35 @@ impl syn::parse::Parse for CallMethodAttribute {
     }
 }
 
+#[derive(Default, Clone)]
+pub struct GetFieldAttribute {
+    reference: Option<(Token![&], Option<Token![mut]>)>,
+    member: Option<syn::Member>,
+}
+
+impl GetFieldAttribute {
+    pub fn reference_tokens(&self) -> Option<TokenStream> {
+        let (ref_, mut_) = self.reference.as_ref()?;
+        let mut tokens = ref_.to_token_stream();
+        mut_.to_tokens(&mut tokens);
+        Some(tokens)
+    }
+}
+
+impl syn::parse::Parse for GetFieldAttribute {
+    fn parse(input: ParseStream) -> Result<Self, Error> {
+        let mut reference = None;
+        if let Ok(ref_) = input.parse::<syn::Token![&]>() {
+            reference = Some((ref_, None));
+        }
+        if let Some((_, mut_)) = &mut reference {
+            *mut_ = input.parse::<syn::Token![mut]>().ok();
+        }
+        let member = input.is_empty().not().then(|| input.parse()).transpose()?;
+        Ok(GetFieldAttribute { reference, member })
+    }
+}
+
 struct GenerateAwaitAttribute {
     literal: syn::LitBool,
 }
@@ -202,10 +231,28 @@ pub enum ReturnExpression {
     Unwrap,
 }
 
+pub enum TargetSpecifier {
+    Field(GetFieldAttribute),
+    Method(CallMethodAttribute),
+}
+
+impl TargetSpecifier {
+    pub fn get_member(&self, default: &syn::Ident) -> syn::Member {
+        match self {
+            Self::Field(GetFieldAttribute {
+                member: Some(member),
+                ..
+            }) => member.clone(),
+            Self::Field(_) => default.clone().into(),
+            Self::Method(method) => method.name.clone().into(),
+        }
+    }
+}
+
 enum ParsedAttribute {
     ReturnExpression(ReturnExpression),
     Await(bool),
-    TargetMethod(syn::Ident),
+    TargetSpecifier(TargetSpecifier),
     ThroughTrait(TraitTarget),
     ConstantAccess(AssociatedConstant),
     Expr(TemplateExpr),
@@ -231,7 +278,19 @@ fn parse_attributes(
                         let target = attribute
                             .parse_args::<CallMethodAttribute>()
                             .expect("Cannot parse `call` attribute");
-                        Some(ParsedAttribute::TargetMethod(target.name))
+                        let spec = TargetSpecifier::Method(target);
+                        Some(ParsedAttribute::TargetSpecifier(spec))
+                    }
+                    "field" => {
+                        let target = if let syn::Meta::Path(_) = &attribute.meta {
+                            GetFieldAttribute::default()
+                        } else {
+                            attribute
+                                .parse_args::<GetFieldAttribute>()
+                                .expect("Cannot parse `field` attribute")
+                        };
+                        let spec = TargetSpecifier::Field(target);
+                        Some(ParsedAttribute::TargetSpecifier(spec))
                     }
                     "into" => {
                         let into = match &attribute.meta {
@@ -300,7 +359,7 @@ fn parse_attributes(
 
 pub struct MethodAttributes<'a> {
     pub attributes: Vec<&'a Attribute>,
-    pub target_method: Option<syn::Ident>,
+    pub target_specifier: Option<TargetSpecifier>,
     pub expressions: VecDeque<ReturnExpression>,
     pub generate_await: Option<bool>,
     pub target_trait: Option<TypePath>,
@@ -320,7 +379,7 @@ pub fn parse_method_attributes<'a>(
     attrs: &'a [Attribute],
     method: &syn::TraitItemFn,
 ) -> MethodAttributes<'a> {
-    let mut target_method: Option<syn::Ident> = None;
+    let mut target_spec: Option<TargetSpecifier> = None;
     let mut expressions: Vec<ReturnExpression> = vec![];
     let mut generate_await: Option<bool> = None;
     let mut target_trait: Option<TraitTarget> = None;
@@ -340,14 +399,14 @@ pub fn parse_method_attributes<'a>(
                 }
                 generate_await = Some(value);
             }
-            ParsedAttribute::TargetMethod(target) => {
-                if target_method.is_some() {
+            ParsedAttribute::TargetSpecifier(spec) => {
+                if target_spec.is_some() {
                     panic!(
-                        "Multiple call attributes specified for {}",
+                        "Multiple field/call attributes specified for {}",
                         method.sig.ident
                     )
                 }
-                target_method = Some(target);
+                target_spec = Some(spec);
             }
             ParsedAttribute::ThroughTrait(target) => {
                 if target_trait.is_some() {
@@ -379,13 +438,13 @@ pub fn parse_method_attributes<'a>(
         }
     }
 
-    if associated_constant.is_some() && target_method.is_some() {
-        panic!("Cannot use both `call` and `const` attributes.");
+    if associated_constant.is_some() && target_spec.is_some() {
+        panic!("Cannot use both `call`/`field` and `const` attributes.");
     }
 
     MethodAttributes {
         attributes: other.into_iter().collect(),
-        target_method,
+        target_specifier: target_spec,
         generate_await,
         expressions: expressions.into(),
         target_trait: target_trait.map(|t| t.type_path),
@@ -425,8 +484,8 @@ pub fn parse_segment_attributes(attrs: &[Attribute]) -> SegmentAttributes {
                 }
                 target_trait = Some(target);
             }
-            ParsedAttribute::TargetMethod(_) => {
-                panic!("Call attribute cannot be specified on a `to <expr>` segment.");
+            ParsedAttribute::TargetSpecifier(_) => {
+                panic!("Field/call attribute cannot be specified on a `to <expr>` segment.");
             }
             ParsedAttribute::ConstantAccess(_) => {
                 panic!("Const attribute cannot be specified on a `to <expr>` segment.");

src/lib.rs

@@ -433,7 +433,44 @@
 //! }
 //!
 //! assert_eq!(Enum::A(A).get_toto(), <A as WithConst>::TOTO);
+//! ```
+//!
+//! - Delegate to fields
+//! ```rust
+//! use delegate::delegate;
+//!
+//! struct Datum {
+//!     value: u32,
+//!     error: u32,
+//! }
+//!
+//! struct DatumWrapper(Datum);
+//!
+//! impl DatumWrapper {
+//!     delegate! {
+//!         to self.0 {
+//!             /// Get the value of a nested field with the same name
+//!             #[field]
+//!             fn value(&self) -> u32;
+//!
+//!             /// Get the value of a nested field with a different name
+//!             #[field(value)]
+//!             fn renamed_value(&self) -> u32;
 //!
+//!             /// Get shared reference to a nested field
+//!             #[field(&value)]
+//!             fn value_ref(&self) -> &u32;
+//!
+//!             /// Get mutable reference to a nested field
+//!             #[field(&mut value)]
+//!             fn value_ref_mut(&mut self) -> &mut u32;
+//!
+//!             /// Get mutable reference to a nested field with the same name
+//!             #[field(&)]
+//!             fn error(&self) -> &u32;
+//!         }
+//!     }
+//! }
 //! ```
 
 extern crate proc_macro;
@@ -451,7 +488,7 @@ use syn::{parse_quote, Error, Expr, ExprField, ExprMethodCall, FnArg, GenericPar
 
 use crate::attributes::{
     combine_attributes, parse_method_attributes, parse_segment_attributes, ReturnExpression,
-    SegmentAttributes,
+    SegmentAttributes, TargetSpecifier,
 };
 
 mod attributes;
@@ -895,10 +932,13 @@ pub fn delegate(tokens: TokenStream) -> TokenStream {
 
             // Generate an argument vector from Punctuated list.
             let args: Vec<Expr> = method.arguments.clone().into_iter().collect();
-            let name = match &attributes.target_method {
-                Some(n) => n,
-                None => &input.sig.ident,
+
+            // Get name (or index) of the target method or field
+            let name = match &attributes.target_specifier {
+                Some(target) => target.get_member(&input.sig.ident),
+                None => input.sig.ident.clone().into(),
             };
+
             let inline = if has_inline_attribute(&attributes.attributes) {
                 quote!()
             } else {
@@ -972,7 +1012,15 @@ pub fn delegate(tokens: TokenStream) -> TokenStream {
                         get_const(#expr)
                     }}
                 } else if is_method {
-                    quote::quote! { #expr.#name#generics(#(#args),*) }
+                    match &attributes.target_specifier {
+                        None | Some(TargetSpecifier::Method(_)) => {
+                            quote::quote! { #expr.#name#generics(#(#args),*) }
+                        }
+                        Some(TargetSpecifier::Field(target)) => {
+                            let reference = target.reference_tokens();
+                            quote::quote! { #reference#expr.#name }
+                        }
+                    }
                 } else {
                     quote::quote! { #expr::#name#generics(#(#args),*) }
                 };

tests/delegation.rs

@@ -1,5 +1,10 @@
 use delegate::delegate;
 
+#[test]
+fn test_expansions() {
+    macrotest::expand("tests/expand/*.rs");
+}
+
 #[test]
 fn test_delegation() {
     struct Inner;

tests/expand/fields.expanded.rs

@@ -0,0 +1,52 @@
+use delegate::delegate;
+struct Datum {
+    value: u32,
+    error: u32,
+    xy: (f32, f32),
+}
+struct DatumWrapper(Datum);
+impl DatumWrapper {
+    fn get_inner(&self) -> &Datum {
+        &self.0
+    }
+    /// Expands to `self.0.value`
+    #[inline]
+    fn value(&self) -> u32 {
+        self.0.value
+    }
+    /// Expands to `self.0.value`
+    #[inline]
+    fn renamed_value(&self) -> u32 {
+        self.0.value
+    }
+    /// Expands to `&self.0.value`
+    #[inline]
+    fn renamed_value_ref(&self) -> &u32 {
+        &self.0.value
+    }
+    /// Expands to `&mut self.0.value`
+    #[inline]
+    fn renamed_value_ref_mut(&mut self) -> &mut u32 {
+        &mut self.0.value
+    }
+    /// Expands to `&self.0.error` (demonstrates `&` without a field name)
+    #[inline]
+    fn error(&self) -> &u32 {
+        &self.0.error
+    }
+    /// Expands to `self.0.xy.0` (demonstrates unnamed field access by value)
+    #[inline]
+    fn x(&self) -> f32 {
+        self.0.xy.0
+    }
+    /// Expands to `&self.0.xy.1` (demonstrates unnamed field access by reference)
+    #[inline]
+    fn y(&self) -> &f32 {
+        &self.0.xy.1
+    }
+    /// Expands to `&self.get_inner().value`
+    #[inline]
+    fn value_ref_via_get_inner(&self) -> &u32 {
+        &self.get_inner().value
+    }
+}