Configuration option to preserve blank lines at start of block

Adds the option for

- Functions
- Control flow blocks
- Expression statements (i.e. `let x = { ... };`)
- Traits
- Trait Impls
- Mods
- Foreign Mods

If I am missing a kind of item, let me know :)

Closes #2868

Author: ayazhafiz

Configurations.md

@@ -1804,6 +1804,35 @@ pub enum Foo {}
 pub enum Foo {}
 ```
 
+## `preserve_block_start_blank_lines`
+
+Preserves blanks lines at the start of the block. Note that this will preserve newlines, but strip
+any other whitespace on those lines.
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No
+
+#### `false` (default):
+
+```rust
+fn say_hi() {
+    println!("hi");
+}
+```
+
+#### `true`:
+
+```rust
+fn say_hi() {
+
+
+    println!("hi");
+}
+```
+
+###
+
 ## `overflow_delimited_expr`
 
 When structs, slices, arrays, and block/array-like macros are used as the last

src/config.rs

@@ -129,6 +129,8 @@ create_config! {
     inline_attribute_width: usize, 0, false,
         "Write an item and its attribute on the same line \
         if their combined width is below a threshold";
+    preserve_block_start_blank_lines: bool, false, false, "Preserve blank lines at the start of \
+        blocks.";
 
     // Options that can change the source code beyond whitespace/blocks (somewhat linty things)
     merge_derives: bool, true, true, "Merge multiple `#[derive(...)]` into a single one";
@@ -615,6 +617,7 @@ blank_lines_upper_bound = 1
 blank_lines_lower_bound = 0
 edition = "2018"
 inline_attribute_width = 0
+preserve_block_start_blank_lines = false
 merge_derives = true
 use_try_shorthand = false
 use_field_init_shorthand = false

src/formatting/items.rs

@@ -221,6 +221,14 @@ enum BodyElement<'a> {
     ForeignItem(&'a ast::ForeignItem),
 }
 
+impl BodyElement<'_> {
+    pub(crate) fn span(&self) -> Span {
+        match self {
+            BodyElement::ForeignItem(fi) => fi.span(),
+        }
+    }
+}
+
 /// Represents a fn's signature.
 pub(crate) struct FnSig<'a> {
     decl: &'a ast::FnDecl,
@@ -333,6 +341,10 @@ impl<'a> FmtVisitor<'a> {
                 let indent_str = self.block_indent.to_string(self.config);
                 self.push_str(&indent_str);
             } else {
+                let first_non_ws = item.body.first().map(|s| s.span().lo());
+                let opening_nls = &self.trim_spaces_after_opening_brace(first_non_ws);
+                self.push_str(&opening_nls);
+
                 for item in &item.body {
                     self.format_body_element(item);
                 }
@@ -854,12 +866,25 @@ pub(crate) fn format_impl(
             visitor.block_indent = item_indent;
             visitor.last_pos = lo + BytePos(open_pos as u32);
 
+            let open_nls = &visitor.trim_spaces_after_opening_brace(
+                inner_attributes(&item.attrs)
+                    .first()
+                    .map(|a| a.span.lo())
+                    .or(items.first().map(|i| i.span().lo())),
+            );
+
             visitor.visit_attrs(&item.attrs, ast::AttrStyle::Inner);
             visitor.visit_impl_items(items);
 
             visitor.format_missing(item.span.hi() - BytePos(1));
 
-            let inner_indent_str = visitor.block_indent.to_string_with_newline(context.config);
+            let inner_indent_str = if !open_nls.is_empty() {
+                result.push_str(open_nls);
+                visitor.block_indent.to_string(context.config)
+            } else {
+                visitor.block_indent.to_string_with_newline(context.config)
+            };
+
             let outer_indent_str = offset.block_only().to_string_with_newline(context.config);
 
             result.push_str(&inner_indent_str);
@@ -1209,13 +1234,21 @@ pub(crate) fn format_trait(
             visitor.block_indent = offset.block_only().block_indent(context.config);
             visitor.last_pos = block_span.lo() + BytePos(open_pos as u32);
 
+            let open_nls = &visitor
+                .trim_spaces_after_opening_brace(trait_items.first().map(|i| i.span().lo()));
+
             for item in trait_items {
                 visitor.visit_trait_item(item);
             }
 
             visitor.format_missing(item.span.hi() - BytePos(1));
 
-            let inner_indent_str = visitor.block_indent.to_string_with_newline(context.config);
+            let inner_indent_str = if !open_nls.is_empty() {
+                result.push_str(open_nls);
+                visitor.block_indent.to_string(context.config)
+            } else {
+                visitor.block_indent.to_string_with_newline(context.config)
+            };
 
             result.push_str(&inner_indent_str);
             result.push_str(visitor.buffer.trim());

src/formatting/visitor.rs

@@ -181,18 +181,56 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
     }
 
     /// Remove spaces between the opening brace and the first statement or the inner attribute
-    /// of the block.
-    fn trim_spaces_after_opening_brace(
+    /// of the block, fast-forwarding this position of the visitor.
+    /// If `preserve_block_start_blank_lines` is true, the return value contains the newlines that
+    /// should be preserved.
+    pub(crate) fn trim_spaces_after_opening_brace(
         &mut self,
-        b: &ast::Block,
-        inner_attrs: Option<&[ast::Attribute]>,
-    ) {
-        if let Some(first_stmt) = b.stmts.first() {
-            let hi = inner_attrs
-                .and_then(|attrs| inner_attributes(attrs).first().map(|attr| attr.span.lo()))
-                .unwrap_or_else(|| first_stmt.span().lo());
-            let missing_span = self.next_span(hi);
+        first_item_pos: Option<BytePos>,
+    ) -> String {
+        let mut result = String::new();
+        if let Some(first_item_pos) = first_item_pos {
+            let missing_span = self.next_span(first_item_pos);
             let snippet = self.snippet(missing_span);
+
+            if self.config.preserve_block_start_blank_lines() {
+                // First we need to find the span to look for blank lines in. This is either the
+                // - span between the opening brace and first item, or
+                // - span between the opening brace and a comment before the first item
+                // We do this so that we get a span of contiguous whitespace, which makes
+                // processing the blank lines easier.
+                let blank_lines_snippet = if let Some(hi) = self
+                    .snippet_provider
+                    .span_to_snippet(missing_span)
+                    .and_then(|s| s.find('/'))
+                {
+                    self.snippet_provider.span_to_snippet(mk_sp(
+                        missing_span.lo(),
+                        missing_span.lo() + BytePos::from_usize(hi),
+                    ))
+                } else {
+                    self.snippet_provider.span_to_snippet(missing_span)
+                };
+
+                if let Some(snippet) = blank_lines_snippet {
+                    let has_multiple_blank_lines =
+                        if let (Some(l), Some(r)) = (snippet.find('\n'), snippet.rfind('\n')) {
+                            l != r
+                        } else {
+                            false
+                        };
+                    if has_multiple_blank_lines {
+                        let mut lines = snippet.lines().map(&str::trim);
+                        lines.next(); // Eat block-opening newline
+                        while let Some("") = lines.next() {
+                            result.push('\n');
+                        }
+                    }
+                } else {
+                    debug!("Failed to preserve blank lines for {:?}", missing_span);
+                }
+            }
+
             let len = CommentCodeSlices::new(snippet)
                 .next()
                 .and_then(|(kind, _, s)| {
@@ -206,6 +244,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
                 self.last_pos = self.last_pos + BytePos::from_usize(len);
             }
         }
+        result
     }
 
     pub(crate) fn visit_block(
@@ -225,7 +264,12 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
         self.last_pos = self.last_pos + brace_compensation;
         self.block_indent = self.block_indent.block_indent(self.config);
         self.push_str("{");
-        self.trim_spaces_after_opening_brace(b, inner_attrs);
+
+        let first_non_ws = inner_attrs
+            .and_then(|attrs| inner_attributes(attrs).first().map(|attr| attr.span.lo()))
+            .or(b.stmts.first().map(|s| s.span().lo()));
+        let opening_nls = &self.trim_spaces_after_opening_brace(first_non_ws);
+        self.push_str(&opening_nls);
 
         // Format inner attributes if available.
         if let Some(attrs) = inner_attrs {
@@ -945,6 +989,14 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
             } else {
                 self.last_pos = mod_lo;
                 self.block_indent = self.block_indent.block_indent(self.config);
+
+                let first_non_ws = inner_attributes(attrs)
+                    .first()
+                    .map(|attr| attr.span.lo())
+                    .or(m.items.first().map(|s| s.span().lo()));
+                let opening_nls = &self.trim_spaces_after_opening_brace(first_non_ws);
+                self.push_str(&opening_nls);
+
                 self.visit_attrs(attrs, ast::AttrStyle::Inner);
                 self.walk_mod_items(m);
                 let missing_span = self.next_span(m.inner.hi() - BytePos(1));