fix: nested comments in control flow condition pat

src/patterns.rs

@@ -92,23 +92,78 @@ impl Rewrite for Pat {
                     BindingMode::ByRef(mutability) => ("ref", mutability),
                     BindingMode::ByValue(mutability) => ("", mutability),
                 };
-                let mut_infix = format_mutability(mutability);
+                let mut_infix = format_mutability(mutability).trim();
                 let id_str = rewrite_ident(context, ident);
                 let sub_pat = match *sub_pat {
                     Some(ref p) => {
-                        // 3 - ` @ `.
+                        // 2 - `@ `.
                         let width = shape
                             .width
-                            .checked_sub(prefix.len() + mut_infix.len() + id_str.len() + 3)?;
+                            .checked_sub(prefix.len() + mut_infix.len() + id_str.len() + 2)?;
-                        format!(
+                        let lo = context.snippet_provider.span_after(self.span, "@");
-                            " @ {}",
+                        combine_strs_with_missing_comments(
-                            p.rewrite(context, Shape::legacy(width, shape.indent))?
+                            context,
-                        )
+                            "@",
+                            &p.rewrite(context, Shape::legacy(width, shape.indent))?,
+                            mk_sp(lo, p.span.lo()),
+                            shape,
+                            true,
+                        )?
                     }
                     None => "".to_owned(),
                 };
 
-                Some(format!("{}{}{}{}", prefix, mut_infix, id_str, sub_pat))
+                // combine prefix and mut
+                let (first_lo, first) = if !prefix.is_empty() && !mut_infix.is_empty() {
+                    let hi = context.snippet_provider.span_before(self.span, "mut");
+                    let lo = context.snippet_provider.span_after(self.span, "ref");
+                    (
+                        context.snippet_provider.span_after(self.span, "mut"),
+                        combine_strs_with_missing_comments(
+                            context,
+                            prefix,
+                            mut_infix,
+                            mk_sp(lo, hi),
+                            shape,
+                            true,
+                        )?,
+                    )
+                } else if !prefix.is_empty() {
+                    (
+                        context.snippet_provider.span_after(self.span, "ref"),
+                        prefix.to_owned(),
+                    )
+                } else if !mut_infix.is_empty() {
+                    (
+                        context.snippet_provider.span_after(self.span, "mut"),
+                        mut_infix.to_owned(),
+                    )
+                } else {
+                    (self.span.lo(), "".to_owned())
+                };
+
+                let next = if !sub_pat.is_empty() {
+                    let hi = context.snippet_provider.span_before(self.span, "@");
+                    combine_strs_with_missing_comments(
+                        context,
+                        id_str,
+                        &sub_pat,
+                        mk_sp(ident.span.hi(), hi),
+                        shape,
+                        true,
+                    )?
+                } else {
+                    id_str.to_owned()
+                };
+
+                combine_strs_with_missing_comments(
+                    context,
+                    &first,
+                    &next,
+                    mk_sp(first_lo, ident.span.lo()),
+                    shape,
+                    true,
+                )
             }
             PatKind::Wild => {
                 if 1 <= shape.width {

tests/source/issue_3853.rs

@@ -0,0 +1,35 @@
+fn by_ref_with_block_before_ident() {
+if let Some(ref     /*def*/      state)=        foo{
+				println!(
+        "asdfasdfasdf");	}
+}
+
+fn mut_block_before_ident() {
+if   let Some(mut     /*def*/    state  ) =foo{
+				println!(
+        "123"   );	}
+}
+
+fn ref_and_mut_blocks_before_ident() {
+if   let Some(ref  /*abc*/
+    mut     /*def*/    state  )    =       foo {
+				println!(
+ "deefefefefefwea"   );	}
+}
+
+fn sub_pattern() {
+    let foo @             /*foo*/
+bar(f) = 42;
+}
+
+fn no_prefix_block_before_ident() {
+if   let Some(
+    /*def*/    state  )    =       foo {
+				println!(
+ "129387123123"   );	}
+}
+
+fn issue_3853() {
+if let Some(ref /*mut*/ state) = foo {
+					}
+}

tests/target/issue_3853.rs

@@ -0,0 +1,31 @@
+fn by_ref_with_block_before_ident() {
+    if let Some(ref /*def*/ state) = foo {
+        println!("asdfasdfasdf");
+    }
+}
+
+fn mut_block_before_ident() {
+    if let Some(mut /*def*/ state) = foo {
+        println!("123");
+    }
+}
+
+fn ref_and_mut_blocks_before_ident() {
+    if let Some(ref /*abc*/ mut /*def*/ state) = foo {
+        println!("deefefefefefwea");
+    }
+}
+
+fn sub_pattern() {
+    let foo @ /*foo*/ bar(f) = 42;
+}
+
+fn no_prefix_block_before_ident() {
+    if let Some(/*def*/ state) = foo {
+        println!("129387123123");
+    }
+}
+
+fn issue_3853() {
+    if let Some(ref /*mut*/ state) = foo {}
+}