added interpretation of the attr tokens passed to the pub_interface macro

* If applied to a trait, the tokens are interpreted as the type that
  implements the trait (this affects code generation, which otherwise
  assumed the implementor was named `Contract`)
* If applied to an impl, and there are extra `attr` tokens, an error is issued.

Author: reuvenpo

eng-wasm/derive/src/lib.rs

@@ -38,8 +38,8 @@ use pub_interface::impl_pub_interface;
 /// all methods declared as pub will be exported by the contract. if placed on an impl block,
 /// the implementing struct can have any name you choose.
 #[proc_macro_attribute]
-pub fn pub_interface(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    impl_pub_interface(item.into()).into()
+pub fn pub_interface(attr: TokenStream, item: TokenStream) -> TokenStream {
+    impl_pub_interface(attr.into(), item.into()).into()
 }
 
 #[proc_macro_attribute]

eng-wasm/derive/src/pub_interface.rs

@@ -4,7 +4,7 @@ use syn::spanned::Spanned;
 mod parse_signatures;
 
 use super::into_ident::IntoIdent;
-use parse_signatures::PubInterfaceSignatures;
+use parse_signatures::{ParseError, PubInterfaceItemType, PubInterfaceSignatures};
 
 const DEFAULT_IMPLEMENTOR_NAME: &str = "Contract";
 const CONSTRUCTOR_NAME: &str = "construct";
@@ -15,9 +15,15 @@ const FUNCTION_NAME_FUNC_NAME: &str = "function_name";
 const ARGS_FUNC_NAME: &str = "args";
 const CALL_FUNC_NAME: &str = "call";
 
-pub(crate) fn impl_pub_interface(item: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+pub(crate) fn impl_pub_interface(
+    attr: proc_macro2::TokenStream,
+    item: proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
     let cloned_item = item.clone();
-    let pub_interface_signatures = parse_macro_input2!(cloned_item as PubInterfaceSignatures);
+    let mut pub_interface_signatures = parse_macro_input2!(cloned_item as PubInterfaceSignatures);
+    if let Err(error) = apply_macro_attr(attr, &mut pub_interface_signatures) {
+        return error.to_compile_error();
+    }
 
     let deploy_func_name = DEPLOY_FUNC_NAME.into_ident();
     let dispatch_func_name = DISPATCH_FUNC_NAME.into_ident();
@@ -44,6 +50,51 @@ pub(crate) fn impl_pub_interface(item: proc_macro2::TokenStream) -> proc_macro2:
     }
 }
 
+/// Parse the arguments to the macro and apply them to the `PubInterfaceSignatures`
+///
+/// The arguments to the macro are the parts written between parenthesis in the macro invocation.
+///
+/// # Examples:
+///
+/// (This never actually gets compiled for some reason. You can try doing
+/// `rustdoc --test src/lib.rs` but that generated compilation errors.
+/// Probably because this is a pro-macro crate.)
+///
+/// ```
+/// # use eng_wasm_derive::pub_interface;
+///
+/// #[pub_interface(MyContract)]
+/// trait ContractInterface {
+///     fn foo();
+/// }
+///
+/// struct MyContract;
+///
+/// impl ContractInterface for MyContract {
+///     fn foo() {}
+/// }
+/// ```
+fn apply_macro_attr(
+    attr: proc_macro2::TokenStream,
+    pub_interface_signatures: &mut PubInterfaceSignatures,
+) -> syn::Result<()> {
+    if attr.is_empty() {
+        return Ok(());
+    }
+
+    match pub_interface_signatures.item_type {
+        PubInterfaceItemType::ItemTrait => {
+            let implementor: syn::Type = syn::parse2(attr)?;
+            pub_interface_signatures.implementor = implementor;
+            Ok(())
+        }
+        PubInterfaceItemType::ItemImpl => Err(syn::Error::new_spanned(
+            attr,
+            ParseError::CustomImplementorOnImpl,
+        )),
+    }
+}
+
 fn generate_eng_wasm_aux_functions(
     function_name_func_name: &syn::Ident,
     args_func_name: &syn::Ident,
@@ -250,6 +301,107 @@ fn generate_dispatch_function(
 mod tests {
     use super::*;
 
+    #[test]
+    fn apply_macro_attr_works_on_trait() {
+        let attr_tokens = quote!(Bar);
+
+        let mut pub_interface_signatures = PubInterfaceSignatures {
+            signatures: vec![],
+            implementor: syn::parse2(quote!(Foo)).unwrap(),
+            item_type: PubInterfaceItemType::ItemTrait,
+        };
+
+        apply_macro_attr(attr_tokens.clone(), &mut pub_interface_signatures).unwrap();
+
+        assert_eq!(
+            syn::parse2::<syn::Type>(attr_tokens).unwrap(),
+            pub_interface_signatures.implementor
+        );
+    }
+
+    #[test]
+    fn apply_macro_attr_with_empty_input_works_on_trait() {
+        let attr_tokens = quote!(); // This is empty
+
+        let mut pub_interface_signatures = PubInterfaceSignatures {
+            signatures: vec![],
+            implementor: syn::parse2(quote!(Foo)).unwrap(),
+            item_type: PubInterfaceItemType::ItemTrait,
+        };
+
+        apply_macro_attr(attr_tokens.clone(), &mut pub_interface_signatures).unwrap();
+
+        // Check that the implementor did not change
+        assert_eq!(
+            syn::parse2::<syn::Type>(quote!(Foo)).unwrap(),
+            pub_interface_signatures.implementor
+        );
+    }
+
+    #[test]
+    fn apply_macro_attr_with_bad_input_fails_on_trait() {
+        let attr_tokens = quote!(this is not a valid type);
+
+        let mut pub_interface_signatures = PubInterfaceSignatures {
+            signatures: vec![],
+            implementor: syn::parse2(quote!(Foo)).unwrap(),
+            item_type: PubInterfaceItemType::ItemTrait,
+        };
+
+        let error =
+            apply_macro_attr(attr_tokens.clone(), &mut pub_interface_signatures).unwrap_err();
+
+        assert_eq!(error.to_string(), "unexpected token");
+        // Check that the implementor did not change
+        assert_eq!(
+            syn::parse2::<syn::Type>(quote!(Foo)).unwrap(),
+            pub_interface_signatures.implementor
+        );
+    }
+
+    #[test]
+    fn apply_macro_attr_with_empty_input_works_on_impl() {
+        let attr_tokens = quote!(); // This is empty
+
+        let mut pub_interface_signatures = PubInterfaceSignatures {
+            signatures: vec![],
+            implementor: syn::parse2(quote!(Foo)).unwrap(),
+            item_type: PubInterfaceItemType::ItemImpl,
+        };
+
+        apply_macro_attr(attr_tokens.clone(), &mut pub_interface_signatures).unwrap();
+
+        // Check that the implementor did not change
+        assert_eq!(
+            syn::parse2::<syn::Type>(quote!(Foo)).unwrap(),
+            pub_interface_signatures.implementor
+        );
+    }
+
+    #[test]
+    fn apply_macro_attr_fails_on_impl() {
+        let attr_tokens = quote!(Bar);
+
+        let mut pub_interface_signatures = PubInterfaceSignatures {
+            signatures: vec![],
+            implementor: syn::parse2(quote!(Foo)).unwrap(),
+            item_type: PubInterfaceItemType::ItemImpl,
+        };
+
+        let error =
+            apply_macro_attr(attr_tokens.clone(), &mut pub_interface_signatures).unwrap_err();
+
+        assert_eq!(
+            error.to_string(),
+            ParseError::CustomImplementorOnImpl.to_string()
+        );
+        // Check that the implementor did not change
+        assert_eq!(
+            syn::parse2::<syn::Type>(quote!(Foo)).unwrap(),
+            pub_interface_signatures.implementor
+        );
+    }
+
     #[test]
     fn deploy_generation() -> syn::Result<()> {
         let input = quote!(

eng-wasm/derive/src/pub_interface/parse_signatures.rs

@@ -14,7 +14,7 @@ use crate::pub_interface::CONSTRUCTOR_NAME;
 ///
 /// This type mostly exists to pass into syn::Error as an error message.
 #[derive(Display, Debug)]
-enum ParseError {
+pub(crate) enum ParseError {
     #[display("pub_interface item must be either a trait or an inherent struct impl")]
     BadInputItem,
 
@@ -47,13 +47,29 @@ enum ParseError {
 
     #[display("methods in impls annotated with pub_interface should be either `fn` or `pub fn`")]
     ImplMethodWithBadVisibility,
+
+    #[display("custom implementors are not supported when pub_interface is applied to `impl`s")]
+    CustomImplementorOnImpl,
 }
 
+/// This enum is used to present the result of the speculative parsing inside
+/// `impl syn::parse::Parse for PubInterfaceSignatures` which tries to parse the macro input
+/// in one of several ways
 enum PubInterfaceInput {
     ItemTrait(syn::ItemTrait),
     ItemImpl(syn::ItemImpl),
 }
 
+/// This enum is used to record what kind of item the macro was applied to.
+///
+/// This information is used later when considering the macro `attr` to modify the
+/// `PubInterfaceSignatures` that was parsed in this module.
+#[derive(Copy, Clone)]
+pub(crate) enum PubInterfaceItemType {
+    ItemTrait,
+    ItemImpl,
+}
+
 /// The signatures collected while parsing the macro input
 #[derive(Clone)]
 pub(crate) struct PubInterfaceSignatures {
@@ -62,6 +78,9 @@ pub(crate) struct PubInterfaceSignatures {
 
     /// The list of exported signatures
     pub(crate) signatures: Vec<syn::Signature>,
+
+    /// This records what kind of item the macro was applied to
+    pub(crate) item_type: PubInterfaceItemType,
 }
 
 impl syn::parse::Parse for PubInterfaceSignatures {
@@ -94,26 +113,30 @@ impl syn::parse::Parse for PubInterfaceSignatures {
         // If none of the options worked, we tell the user that he gave us bad input.
         .map_err(|_err| input.error(ParseError::BadInputItem))?;
 
-        let mut implementor: syn::Type;
+        let item_type: PubInterfaceItemType;
+        let implementor: syn::Type;
         let signatures = match pub_interface_input {
             PubInterfaceInput::ItemTrait(item_trait) => {
+                item_type = PubInterfaceItemType::ItemTrait;
                 let default_implementor_name = super::DEFAULT_IMPLEMENTOR_NAME.into_ident();
                 implementor = syn::parse2::<syn::Type>(quote!(#default_implementor_name)).unwrap();
                 get_signatures_from_item_trait(item_trait)
             }
             PubInterfaceInput::ItemImpl(item_impl) => {
                 if let Some(trait_) = item_impl.trait_ {
                     return Err(syn::Error::new_spanned(trait_.1, ParseError::TraitImpl));
-                } else {
-                    implementor = *item_impl.self_ty.clone();
-                    get_signatures_from_item_impl(item_impl)
                 }
+
+                item_type = PubInterfaceItemType::ItemImpl;
+                implementor = *item_impl.self_ty.clone();
+                get_signatures_from_item_impl(item_impl)
             }
         }?;
 
         Ok(Self {
             implementor,
             signatures,
+            item_type,
         })
     }
 }