From dce3b187743773c109233ea048d59dfeb3521d8c Mon Sep 17 00:00:00 2001
From: calebcartwright <caleb.cartwright@outlook.com>
Date: Thu, 12 Sep 2019 20:46:14 -0500
Subject: [PATCH] feat: support parameter attributes

---
 src/items.rs                        | 42 ++++++++++++++++++++-------
 tests/source/fn-param-attributes.rs | 45 +++++++++++++++++++++++++++++
 tests/target/fn-param-attributes.rs | 45 +++++++++++++++++++++++++++++
 3 files changed, 121 insertions(+), 11 deletions(-)
 create mode 100644 tests/source/fn-param-attributes.rs
 create mode 100644 tests/target/fn-param-attributes.rs

diff --git a/src/items.rs b/src/items.rs
index 613f9b5b729..b698f0c4815 100644
--- a/src/items.rs
+++ b/src/items.rs
@@ -1905,12 +1905,22 @@ fn get_missing_arg_comments(
 
 impl Rewrite for ast::Param {
     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+        let mut param_attrs_result = self
+            .attrs
+            .to_vec()
+            .rewrite(context, Shape::legacy(shape.width, shape.indent))?;
+        if !self.attrs.is_empty() {
+            param_attrs_result = format!("{} ", param_attrs_result);
+        }
         if let Some(ref explicit_self) = self.to_self() {
-            rewrite_explicit_self(context, explicit_self)
+            rewrite_explicit_self(context, explicit_self, &param_attrs_result)
         } else if is_named_arg(self) {
-            let mut result = self
-                .pat
-                .rewrite(context, Shape::legacy(shape.width, shape.indent))?;
+            let mut result = format!(
+                "{}{}",
+                param_attrs_result,
+                self.pat
+                    .rewrite(context, Shape::legacy(shape.width, shape.indent))?,
+            );
 
             if !is_empty_infer(&*self.ty, self.pat.span) {
                 let (before_comment, after_comment) =
@@ -1936,6 +1946,7 @@ impl Rewrite for ast::Param {
 fn rewrite_explicit_self(
     context: &RewriteContext<'_>,
     explicit_self: &ast::ExplicitSelf,
+    param_attrs: &str,
 ) -> Option<String> {
     match explicit_self.node {
         ast::SelfKind::Region(lt, m) => {
@@ -1946,9 +1957,9 @@ fn rewrite_explicit_self(
                         context,
                         Shape::legacy(context.config.max_width(), Indent::empty()),
                     )?;
-                    Some(format!("&{} {}self", lifetime_str, mut_str))
+                    Some(format!("{}&{} {}self", param_attrs, lifetime_str, mut_str))
                 }
-                None => Some(format!("&{}self", mut_str)),
+                None => Some(format!("{}&{}self", param_attrs, mut_str)),
             }
         }
         ast::SelfKind::Explicit(ref ty, mutability) => {
@@ -1958,20 +1969,29 @@ fn rewrite_explicit_self(
             )?;
 
             Some(format!(
-                "{}self: {}",
+                "{}{}self: {}",
+                param_attrs,
                 format_mutability(mutability),
                 type_str
             ))
         }
-        ast::SelfKind::Value(mutability) => Some(format!("{}self", format_mutability(mutability))),
+        ast::SelfKind::Value(mutability) => Some(format!(
+            "{}{}self",
+            param_attrs,
+            format_mutability(mutability)
+        )),
     }
 }
 
 pub(crate) fn span_lo_for_arg(arg: &ast::Param) -> BytePos {
-    if is_named_arg(arg) {
-        arg.pat.span.lo()
+    if arg.attrs.is_empty() {
+        if is_named_arg(arg) {
+            arg.pat.span.lo()
+        } else {
+            arg.ty.span.lo()
+        }
     } else {
-        arg.ty.span.lo()
+        arg.attrs[0].span.lo()
     }
 }
 
diff --git a/tests/source/fn-param-attributes.rs b/tests/source/fn-param-attributes.rs
new file mode 100644
index 00000000000..c4d7f9c1b49
--- /dev/null
+++ b/tests/source/fn-param-attributes.rs
@@ -0,0 +1,45 @@
+// https://github.com/rust-lang/rustfmt/issues/3623
+
+fn foo(#[cfg(something)] x: i32, y: i32) -> i32 {
+    x + y
+}
+
+fn foo_b(#[cfg(something)]x: i32, y: i32) -> i32 {
+    x + y
+}
+
+fn add(#[cfg(something)]#[deny(C)]  x: i32, y: i32) -> i32 {
+    x + y
+}
+
+struct NamedSelfRefStruct {}
+impl NamedSelfRefStruct {
+    fn foo(
+#[cfg(something)]  self: &Self,
+    ) {}
+}
+
+struct MutStruct {}
+impl MutStruct {
+    fn foo(
+        #[cfg(foo)]&mut self,#[deny(C)] b: i32,
+    ) {}
+}
+
+fn main() {
+    let c = |
+        #[allow(C)]a: u32,
+        #[cfg(something)] b: i32,
+        #[cfg_attr(something, cfg(nothing))]#[deny(C)] c: i32,
+    | {};
+    let _ = c(1, 2);
+}
+
+pub fn bar(
+    /// bar
+#[test] a: u32,
+    /// Bar
+            #[must_use]
+/// Baz
+    #[no_mangle] b: i32,
+) {}
diff --git a/tests/target/fn-param-attributes.rs b/tests/target/fn-param-attributes.rs
new file mode 100644
index 00000000000..b7bef23b9a7
--- /dev/null
+++ b/tests/target/fn-param-attributes.rs
@@ -0,0 +1,45 @@
+// https://github.com/rust-lang/rustfmt/issues/3623
+
+fn foo(#[cfg(something)] x: i32, y: i32) -> i32 {
+    x + y
+}
+
+fn foo_b(#[cfg(something)] x: i32, y: i32) -> i32 {
+    x + y
+}
+
+fn add(
+    #[cfg(something)]
+    #[deny(C)] x: i32,
+    y: i32,
+) -> i32 {
+    x + y
+}
+
+struct NamedSelfRefStruct {}
+impl NamedSelfRefStruct {
+    fn foo(#[cfg(something)] self: &Self) {}
+}
+
+struct MutStruct {}
+impl MutStruct {
+    fn foo(#[cfg(foo)] &mut self, #[deny(C)] b: i32) {}
+}
+
+fn main() {
+    let c = |#[allow(C)] a: u32,
+             #[cfg(something)] b: i32,
+             #[cfg_attr(something, cfg(nothing))]
+             #[deny(C)] c: i32| {};
+    let _ = c(1, 2);
+}
+
+pub fn bar(
+    /// bar
+    #[test] a: u32,
+    /// Bar
+    #[must_use]
+    /// Baz
+    #[no_mangle] b: i32,
+) {
+}