Implement support for binding attributes on parameters.

This commit implements support for binding attributes on parameters.

For example:

```rust
pub fn foo(#[binding(route = "foo") req: HttpRequest) {
}
```

However, both `rustfmt` and `rls` (plus GitHub's source parser) do not yet
properly handle attributes on parameters.

The samples and documentation will be updated to specify the attributes on the
parameters themselves once there is broader support of the feature.

Closes #457.

Author: peterhuene

azure-functions-codegen/src/func.rs

@@ -1,7 +1,7 @@
 mod invoker;
 mod output_bindings;
 
-use crate::{attribute_args_from_name, parse_attribute_args};
+use crate::{create_name_attribute_arg, parse_attribute_args};
 use azure_functions_shared::codegen::{
     bindings::{
         Binding, BindingFactory, INPUT_BINDINGS, INPUT_OUTPUT_BINDINGS, OUTPUT_BINDINGS, TRIGGERS,
@@ -335,47 +335,59 @@ fn get_input_binding_factory(
     }
 }
 
-fn bind_input_type(
-    pattern: &Pat,
-    tp: &TypePath,
-    mutability: Option<Mut>,
-    has_trigger: bool,
-    binding_args: &mut HashMap<String, (AttributeArgs, Span)>,
-) -> Binding {
-    let factory = get_input_binding_factory(tp, mutability, has_trigger);
+fn drain_argument_binding_attribute(
+    attrs: &mut Vec<Attribute>,
+    name: &str,
+) -> Option<(AttributeArgs, Span)> {
+    let mut result = None;
+    for attr in attrs
+        .iter()
+        .filter(|a| last_segment_in_path(&a.path).ident == "binding")
+    {
+        if result.is_some() {
+            macro_panic(
+                attr.span(),
+                "parameters cannot have more than one binding attribute",
+            );
+        }
 
-    match pattern {
-        Pat::Ident(name) => {
-            let name_str = name.ident.to_string();
-            match binding_args.remove(&name_str) {
-                Some(args) => (*factory)(args.0, args.1),
-                None => {
-                    let name_span = name.ident.span();
-                    (*factory)(attribute_args_from_name(&name_str, name_span), name_span)
-                }
+        let mut args = parse_attribute_args(&attr);
+
+        iter_attribute_args(&args, |key, _| {
+            if key == "name" {
+                macro_panic(
+                    attr.span(),
+                    "parameter binding attributes cannot have a 'name' argument",
+                );
             }
-        }
-        _ => macro_panic(pattern.span(), "bindings must have a named identifier"),
+            true
+        });
+
+        args.push(create_name_attribute_arg(name, attr.span()));
+
+        result = Some((args, attr.span()));
     }
+
+    attrs.retain(|a| last_segment_in_path(&a.path).ident != "binding");
+
+    result
 }
 
 fn bind_argument(
-    arg: &FnArg,
+    arg: &mut FnArg,
     has_trigger: bool,
     binding_args: &mut HashMap<String, (AttributeArgs, Span)>,
 ) -> Binding {
-    match arg {
+    let (pat, tp, mutability, attrs) = match arg {
         FnArg::Typed(arg) => match &*arg.ty {
             Type::Reference(tr) => match &*tr.elem {
-                Type::Path(tp) => {
-                    bind_input_type(&*arg.pat, tp, tr.mutability, has_trigger, binding_args)
-                }
+                Type::Path(tp) => (&*arg.pat, tp, tr.mutability, &mut arg.attrs),
                 _ => macro_panic(
                     arg.ty.span(),
                     "expected an Azure Functions trigger or input binding type",
                 ),
             },
-            Type::Path(tp) => bind_input_type(&*arg.pat, tp, None, has_trigger, binding_args),
+            Type::Path(tp) => (&*arg.pat, tp, None, &mut arg.attrs),
             _ => macro_panic(
                 arg.ty.span(),
                 "expected an Azure Functions trigger or input binding type",
@@ -384,6 +396,40 @@ fn bind_argument(
         FnArg::Receiver(_) => {
             macro_panic(arg.span(), "Azure Functions cannot have self parameters")
         }
+    };
+
+    let factory = get_input_binding_factory(tp, mutability, has_trigger);
+
+    match pat {
+        Pat::Ident(name) => {
+            let name_str = name.ident.to_string();
+            let binding_attr = drain_argument_binding_attribute(attrs, &name_str);
+
+            let binding_args = match binding_args.remove(&name_str) {
+                Some(args) => {
+                    if let Some(binding_attr) = binding_attr {
+                        macro_panic(
+                            binding_attr.1,
+                            "parameter already has a binding attribute at the function level",
+                        );
+                    }
+                    args
+                }
+                None => binding_attr.unwrap_or_else(|| {
+                    let name_span = name.ident.span();
+                    (
+                        vec![create_name_attribute_arg(&name_str, name_span)],
+                        name_span,
+                    )
+                }),
+            };
+
+            (*factory)(binding_args.0, binding_args.1)
+        }
+        _ => macro_panic(
+            pat.span(),
+            "parameter bindings must have a named identifier",
+        ),
     }
 }
 
@@ -409,7 +455,7 @@ fn bind_output_type(
                 Some(args) => (*factory)(args.0, args.1),
                 None => {
                     let span = tp.span();
-                    (*factory)(attribute_args_from_name(name, span), span)
+                    (*factory)(vec![create_name_attribute_arg(name, span)], span)
                 }
             }
         }
@@ -472,27 +518,30 @@ fn drain_binding_attributes(attrs: &mut Vec<Attribute>) -> HashMap<String, (Attr
         .iter()
         .filter(|a| last_segment_in_path(&a.path).ident == "binding")
     {
-        let attr_span = attr.span();
         let args = parse_attribute_args(&attr);
         let mut name = None;
-        let mut name_span = None;
 
         iter_attribute_args(&args, |key, value| {
             if key != "name" {
                 return true;
             }
 
             name = Some(get_string_value("name", value));
-            name_span = Some(key.span());
             false
         });
 
         if name.is_none() {
-            macro_panic(attr_span, "binding attributes must have a 'name' argument");
+            macro_panic(
+                attr.span(),
+                "binding attributes must have a 'name' argument",
+            );
         }
 
         if map.insert(name.unwrap(), (args, attr.span())).is_some() {
-            macro_panic(attr_span, "binding attributes must have a 'name' argument");
+            macro_panic(
+                attr.span(),
+                "binding attributes must have a 'name' argument",
+            );
         }
     }
 
@@ -535,8 +584,8 @@ pub fn func_impl(
     let mut binding_args = drain_binding_attributes(&mut target.attrs);
     let mut names = HashSet::new();
     let mut has_trigger = false;
-    for arg in &target.sig.inputs {
-        let binding = bind_argument(&arg, has_trigger, &mut binding_args);
+    for arg in target.sig.inputs.iter_mut() {
+        let binding = bind_argument(arg, has_trigger, &mut binding_args);
         has_trigger |= binding.is_trigger();
 
         if let Some(name) = binding.name() {

azure-functions-codegen/src/lib.rs

@@ -31,12 +31,12 @@ fn parse_attribute_args(attr: &Attribute) -> AttributeArgs {
         .unwrap()
 }
 
-fn attribute_args_from_name(name: &str, span: Span) -> AttributeArgs {
-    vec![NestedMeta::Meta(Meta::NameValue(MetaNameValue {
+fn create_name_attribute_arg(name: &str, span: Span) -> NestedMeta {
+    NestedMeta::Meta(Meta::NameValue(MetaNameValue {
         path: Ident::new("name", span).into(),
         eq_token: Eq { spans: [span] },
         lit: Lit::Str(LitStr::new(name, span)),
-    }))]
+    }))
 }
 
 /// Implements the `export!` macro.