Added keep_attr to #[ink::contract] and #[ink::trait_definition]

crates/lang/codegen/src/generator/as_dependency/call_builder.rs

@@ -279,7 +279,11 @@ impl CallBuilder<'_> {
             ir::Receiver::Ref => quote! { build },
             ir::Receiver::RefMut => quote! { build_mut },
         };
-        let attrs = message.attrs();
+        let attrs = self
+            .contract
+            .config()
+            .whitelisted_attributes()
+            .filter_attr(message.attrs().to_vec());
         quote_spanned!(span=>
             type #output_ident = <<<
                 Self
@@ -356,7 +360,11 @@ impl CallBuilder<'_> {
         let span = message.span();
         let callable = message.callable();
         let message_ident = message.ident();
-        let attrs = message.attrs();
+        let attrs = self
+            .contract
+            .config()
+            .whitelisted_attributes()
+            .filter_attr(message.attrs().to_vec());
         let selector = message.composed_selector();
         let selector_bytes = selector.hex_lits();
         let input_bindings = generator::input_bindings(callable.inputs());

crates/lang/codegen/src/generator/as_dependency/contract_ref.rs

@@ -332,7 +332,11 @@ impl ContractRef<'_> {
     ) -> TokenStream2 {
         use ir::Callable as _;
         let span = message.span();
-        let attrs = message.attrs();
+        let attrs = self
+            .contract
+            .config()
+            .whitelisted_attributes()
+            .filter_attr(message.attrs().to_vec());
         let storage_ident = self.contract.module().storage().ident();
         let message_ident = message.ident();
         let call_operator = match message.receiver() {
@@ -375,7 +379,11 @@ impl ContractRef<'_> {
         constructor: ir::CallableWithSelector<ir::Constructor>,
     ) -> TokenStream2 {
         let span = constructor.span();
-        let attrs = constructor.attrs();
+        let attrs = self
+            .contract
+            .config()
+            .whitelisted_attributes()
+            .filter_attr(constructor.attrs().to_vec());
         let constructor_ident = constructor.ident();
         let selector_bytes = constructor.composed_selector().hex_lits();
         let input_bindings = generator::input_bindings(constructor.inputs());

crates/lang/codegen/src/generator/trait_def/call_builder.rs

@@ -357,7 +357,12 @@ impl CallBuilder<'_> {
     ) -> TokenStream2 {
         let span = message.span();
         let message_ident = message.ident();
-        let attrs = message.attrs();
+        let attrs = self
+            .trait_def
+            .trait_def
+            .config()
+            .whitelisted_attributes()
+            .filter_attr(message.attrs());
         let output_ident = generator::output_ident(message_ident);
         let output = message.output();
         let output_sig = output.map_or_else(

crates/lang/codegen/src/generator/trait_def/call_forwarder.rs

@@ -388,7 +388,12 @@ impl CallForwarder<'_> {
         let trait_ident = self.trait_def.trait_def.item().ident();
         let forwarder_ident = self.ident();
         let message_ident = message.ident();
-        let attrs = message.attrs();
+        let attrs = self
+            .trait_def
+            .trait_def
+            .config()
+            .whitelisted_attributes()
+            .filter_attr(message.attrs());
         let output_ident = generator::output_ident(message_ident);
         let output_type = message
             .output()

crates/lang/ir/src/ir/config.rs

@@ -14,9 +14,11 @@
 
 use crate::{
     ast,
+    ast::MetaNameValue,
     error::ExtError as _,
 };
 use core::convert::TryFrom;
+use std::collections::HashMap;
 use syn::spanned::Spanned;
 
 /// The ink! configuration.
@@ -38,6 +40,60 @@ pub struct Config {
     /// be used to change the underlying environmental types of an ink! smart
     /// contract.
     env: Option<Environment>,
+    /// The set of attributes that can be passed to call builder in the codegen.
+    whitelisted_attributes: WhitelistedAttributes,
+}
+
+/// The set of attributes that can be passed to call builder or call forwarder in the codegen.
+#[derive(Debug, PartialEq, Eq)]
+pub struct WhitelistedAttributes(pub HashMap<String, ()>);
+
+impl Default for WhitelistedAttributes {
+    fn default() -> Self {
+        Self(HashMap::from([
+            // Conditional compilation
+            ("cfg".to_string(), ()),
+            ("cfg_attr".to_string(), ()),
+            // Diagnostics
+            ("allow".to_string(), ()),
+            ("warn".to_string(), ()),
+            ("deny".to_string(), ()),
+            ("forbid".to_string(), ()),
+            ("deprecated".to_string(), ()),
+            ("must_use".to_string(), ()),
+            // Documentation
+            ("doc".to_string(), ()),
+        ]))
+    }
+}
+
+impl WhitelistedAttributes {
+    pub fn parse_arg_value(&mut self, arg: &MetaNameValue) -> Result<(), syn::Error> {
+        return if let ast::PathOrLit::Lit(syn::Lit::Str(attributes)) = &arg.value {
+            attributes.value().split(',').for_each(|attribute| {
+                self.0.insert(attribute.trim().to_string(), ());
+            });
+            Ok(())
+        } else {
+            Err(format_err_spanned!(
+                arg,
+                "expected a string with attributes separated by `,`",
+            ))
+        }
+    }
+
+    pub fn filter_attr(&self, attrs: Vec<syn::Attribute>) -> Vec<syn::Attribute> {
+        attrs
+            .into_iter()
+            .filter(|attr| {
+                if let Some(ident) = attr.path.get_ident() {
+                    self.0.contains_key(&ident.to_string())
+                } else {
+                    false
+                }
+            })
+            .collect()
+    }
 }
 
 /// Return an error to notify about duplicate ink! configuration arguments.
@@ -65,6 +121,8 @@ impl TryFrom<ast::AttributeArgs> for Config {
         let mut dynamic_storage_allocator: Option<(bool, ast::MetaNameValue)> = None;
         let mut as_dependency: Option<(bool, ast::MetaNameValue)> = None;
         let mut env: Option<(Environment, ast::MetaNameValue)> = None;
+        let mut whitelisted_attributes = WhitelistedAttributes::default();
+
         for arg in args.into_iter() {
             if arg.name.is_ident("dynamic_storage_allocator") {
                 if let Some((_, ast)) = dynamic_storage_allocator {
@@ -106,6 +164,10 @@ impl TryFrom<ast::AttributeArgs> for Config {
                         "expected a path for `env` ink! configuration argument",
                     ))
                 }
+            } else if arg.name.is_ident("keep_attr") {
+                if let Err(err) = whitelisted_attributes.parse_arg_value(&arg) {
+                    return Err(err)
+                }
             } else {
                 return Err(format_err_spanned!(
                     arg,
@@ -117,6 +179,7 @@ impl TryFrom<ast::AttributeArgs> for Config {
             dynamic_storage_allocator: dynamic_storage_allocator.map(|(value, _)| value),
             as_dependency: as_dependency.map(|(value, _)| value),
             env: env.map(|(value, _)| value),
+            whitelisted_attributes,
         })
     }
 }
@@ -149,6 +212,11 @@ impl Config {
     pub fn is_compile_as_dependency_enabled(&self) -> bool {
         self.as_dependency.unwrap_or(false)
     }
+
+    /// Return set of attributes that can be passed to call builder in the codegen.
+    pub fn whitelisted_attributes(&self) -> &WhitelistedAttributes {
+        &self.whitelisted_attributes
+    }
 }
 
 /// The environmental types definition.
@@ -198,6 +266,7 @@ mod tests {
                 dynamic_storage_allocator: Some(true),
                 as_dependency: None,
                 env: None,
+                whitelisted_attributes: Default::default(),
             }),
         )
     }
@@ -220,6 +289,7 @@ mod tests {
                 dynamic_storage_allocator: None,
                 as_dependency: Some(false),
                 env: None,
+                whitelisted_attributes: Default::default(),
             }),
         )
     }
@@ -246,6 +316,7 @@ mod tests {
                 env: Some(Environment {
                     path: syn::parse_quote! { ::my::env::Types },
                 }),
+                whitelisted_attributes: Default::default(),
             }),
         )
     }
@@ -276,4 +347,30 @@ mod tests {
             Err("encountered duplicate ink! `env` configuration argument"),
         );
     }
+
+    #[test]
+    fn keep_attr_works() {
+        let mut attrs = WhitelistedAttributes::default();
+        attrs.0.insert("foo".to_string(), ());
+        attrs.0.insert("bar".to_string(), ());
+        assert_try_from(
+            syn::parse_quote! {
+                keep_attr = "foo, bar"
+            },
+            Ok(Config {
+                dynamic_storage_allocator: None,
+                as_dependency: None,
+                env: None,
+                whitelisted_attributes: attrs,
+            }),
+        )
+    }
+
+    #[test]
+    fn keep_attr_invalid_value_fails() {
+        assert_try_from(
+            syn::parse_quote! { keep_attr = 1u16 },
+            Err("expected a string with attributes separated by `,`"),
+        );
+    }
 }

crates/lang/ir/src/ir/trait_def/config.rs

@@ -15,6 +15,7 @@
 use crate::{
     ast,
     error::ExtError as _,
+    ir::config::WhitelistedAttributes,
 };
 use core::convert::TryFrom;
 use syn::spanned::Spanned;
@@ -30,6 +31,8 @@ pub struct TraitDefinitionConfig {
     /// selectors of the ink! trait messages. This is useful to disambiguate
     /// ink! trait definitions with equal names.
     namespace: Option<syn::LitStr>,
+    /// The set of attributes that can be passed to call builder and forwarder in the codegen.
+    whitelisted_attributes: WhitelistedAttributes,
 }
 
 impl TraitDefinitionConfig {
@@ -69,6 +72,7 @@ impl TryFrom<ast::AttributeArgs> for TraitDefinitionConfig {
 
     fn try_from(args: ast::AttributeArgs) -> Result<Self, Self::Error> {
         let mut namespace: Option<(syn::LitStr, ast::MetaNameValue)> = None;
+        let mut whitelisted_attributes = WhitelistedAttributes::default();
         for arg in args.into_iter() {
             if arg.name.is_ident("namespace") {
                 if let Some((_, meta_name_value)) = namespace {
@@ -88,6 +92,10 @@ impl TryFrom<ast::AttributeArgs> for TraitDefinitionConfig {
                         "expected a string literal for `namespace` ink! trait definition configuration argument",
                     ))
                 }
+            } else if arg.name.is_ident("keep_attr") {
+                if let Err(err) = whitelisted_attributes.parse_arg_value(&arg) {
+                    return Err(err)
+                }
             } else {
                 return Err(format_err_spanned!(
                     arg,
@@ -97,6 +105,7 @@ impl TryFrom<ast::AttributeArgs> for TraitDefinitionConfig {
         }
         Ok(TraitDefinitionConfig {
             namespace: namespace.map(|(value, _)| value),
+            whitelisted_attributes,
         })
     }
 }
@@ -106,4 +115,10 @@ impl TraitDefinitionConfig {
     pub fn namespace(&self) -> Option<&syn::LitStr> {
         self.namespace.as_ref()
     }
+
+    /// Returns the set of attributes that can be passed to call builder and
+    /// forwarder in the codegen.
+    pub fn whitelisted_attributes(&self) -> &WhitelistedAttributes {
+        &self.whitelisted_attributes
+    }
 }