feat: support parameter attributes

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_result = self
+            .attrs
+            .to_vec()
+            .rewrite(context, Shape::legacy(shape.width, shape.indent))?;
+        if !self.attrs.is_empty() {
+            param_result = format!("{} ", param_result);
+        }
         if let Some(ref explicit_self) = self.to_self() {
-            rewrite_explicit_self(context, explicit_self)
+            rewrite_explicit_self(context, explicit_self, &param_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_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()
     }
 }
 

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,
+) {}

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,
+) {
+}