Add support for newline-after-block (#221)

* Add support for `newline-after-block`

This adds a new check type to enforce newline after any block (closing
`}`). In addition, it also makes the check for empty line while using
`case-max-lines` a bit more strict by now _not_ counting a trailing
comment as an empty line.

While doing this, there's a new column based logic to figure out where
the newline should go in the end of a case. If it's aligned with the
last statement of the case body the line is inserted after. If it's
aligned with then next case arm, the line is inserted before the
comment.

While working on this we're also moving to a line based check that uses
`LineStart` to make replacements and with that simplifying some comment
parsing since we only need to know the pos where the line starts. This
also allowed to add support to fix removal of whitespaces both before
_and_ after leading comments in blocks.

* Use `ast.Pos` when checking comments

We don't need to check line number to find relevant comments, if we
instead use the `ast.Pos` as long as possible we save a ton of
conversions and gets some speed improvement.

* Make `isErrNotNilCheck` check stmt type

Removes extra check for statement type before calling function.

Also adds a more detailed comment to why we skip complex groups.

* Don't create `CommentMap` for file

* Improve trailing case comments handling

* Add support to remove newline after left-aligned comment

Similar to how we do support trailing comments in a block, but no
newline after the comment, we want to support left-aligned comments in
case bodies but keep them flush against the next case.

* Improve method name

* Use constant instead of magic number

* Improve finding comments after blocks

* Consider comments when checking case total lines

* Remove more `NewCommentMap` calls

* Skip `FuncLit` for newline after block

Author: bombsimon

CHECKS.md

@@ -18,6 +18,7 @@
   - [`inc-dec`](#inc-dec)
   - [`label`](#label)
   - [`leading-whitespace`](#leading-whitespace)
+  - [`newline-after-block`](#newline-after-block)
   - [`range`](#range)
   - [`return`](#return)
   - [`select`](#select)
@@ -28,6 +29,7 @@
 - [Configuration](#configuration)
   - [`allow-first-in-block`](#allow-first-in-block)
   - [`allow-whole-block`](#allow-whole-block)
+  - [`case-max-lines`](#case-max-lines)
 
 ## Checks
 
@@ -1282,6 +1284,68 @@ if true {
 
 </tbody></table>
 
+### `newline-after-block`
+
+Block statements (`if`, `for`, `switch`, etc.) should be followed by a blank
+line to visually separate them from subsequent code.
+
+> **NOTE** An exception is made for `defer` statements that follow an
+> `if err != nil` block when the defer references a variable assigned on the
+> line above the if statement. This is a common pattern for resource cleanup.
+
+<table>
+<thead><tr><th>Bad</th><th>Good</th></tr></thead>
+<tbody>
+<tr><td valign="top">
+
+```go
+if true {
+    fmt.Println("hello")
+}
+fmt.Println("world") // 1
+
+for i := 0; i < 3; i++ {
+    fmt.Println(i)
+}
+x := 1 // 2
+```
+
+</td><td valign="top">
+
+```go
+if true {
+    fmt.Println("hello")
+}
+
+fmt.Println("world")
+
+for i := 0; i < 3; i++ {
+    fmt.Println(i)
+}
+
+x := 1
+
+// Exception: defer after error check
+f, err := os.Open("file.txt")
+if err != nil {
+    return err
+}
+defer f.Close()
+```
+
+</td></tr>
+
+<tr><td valign="top">
+
+<sup>1</sup> Missing whitespace after block
+
+<sup>2</sup> Missing whitespace after block
+
+</td><td valign="top">
+
+</td></tr>
+</tbody></table>
+
 ### `trailing-whitespace`
 
 <table>
@@ -1357,3 +1421,126 @@ if anotherVariable {
     }
 }
 ```
+
+### `case-max-lines`
+
+When set to a value greater than 0, case clauses in `switch` and `select`
+statements that exceed this number of lines will require a blank line before the
+next case. Setting this to 1 will make it always enabled.
+
+Comments between case clauses are handled based on their indentation:
+
+- **Indented comments** (deeper than `case`) are treated as trailing comments
+  that belong to the current case body.
+- **Left-aligned comments** (at the same level as `case`) are treated as leading
+  comments that belong to the next case.
+
+The blank line is placed at the transition point between trailing and leading
+content. This means:
+
+- If all comments are indented, the blank line goes before the next `case`.
+- If all comments are left-aligned, the blank line goes after the last
+  statement.
+- If comments transition from indented to left-aligned, the blank line goes at
+  the transition point.
+
+Additionally, left-aligned comments must be flush against the next `case` - no
+blank line is allowed between them. This ensures consistent formatting where
+leading comments are visually attached to the case they describe.
+
+<table>
+<thead><tr><th>Bad</th><th>Good</th></tr></thead>
+<tbody>
+<tr><td valign="top">
+
+```go
+switch n {
+case 1:
+    fmt.Println("hello")
+case 2: // 1
+    fmt.Println("world")
+}
+
+switch n {
+case 1:
+    fmt.Println("hello")
+    // Trailing comment
+case 2: // 2
+    fmt.Println("world")
+}
+
+switch n {
+case 1:
+    fmt.Println("hello")
+    // Trailing comment
+// Leading comment
+case 2: // 3
+    fmt.Println("world")
+}
+
+switch n {
+case 1:
+    fmt.Println("hello")
+// Leading comment
+
+case 2: // 4
+    fmt.Println("world")
+}
+```
+
+</td><td valign="top">
+
+```go
+switch n {
+case 1:
+    fmt.Println("hello")
+
+case 2:
+    fmt.Println("world")
+}
+
+switch n {
+case 1:
+    fmt.Println("hello")
+    // Trailing comment
+
+case 2:
+    fmt.Println("world")
+}
+
+switch n {
+case 1:
+    fmt.Println("hello")
+    // Trailing comment
+
+// Leading comment
+case 2:
+    fmt.Println("world")
+}
+
+switch n {
+case 1:
+    fmt.Println("hello")
+
+// Leading comment
+case 2:
+    fmt.Println("world")
+}
+```
+
+</td></tr>
+
+<tr><td valign="top">
+
+<sup>1</sup> Missing blank line after case body
+
+<sup>2</sup> Missing blank line after trailing comment
+
+<sup>3</sup> Missing blank line at transition (after trailing comment)
+
+<sup>4</sup> Unnecessary blank line before case (after leading comment)
+
+</td><td valign="top">
+
+</td></tr>
+</tbody></table>

README.md

@@ -73,6 +73,7 @@ For more details and examples, see [CHECKS](CHECKS.md).
 - ✅ **err** - Error checking must follow immediately after the error variable
   is assigned
 - ✅ **leading-whitespace** - Disallow leading empty lines in blocks
+- ❌ **newline-after-block** - Require empty line after block statements
 - ✅ **trailing-whitespace** - Disallow trailing empty lines in blocks
 
 ### Configuration
@@ -167,6 +168,7 @@ linters:
       disable:
         - assign-exclusive
         - assign-expr
+        - newline-after-block
 ```
 
 ## See also

analyzer_test.go

@@ -108,6 +108,23 @@ func TestWithConfig(t *testing.T) {
 				config.Checks.Add(CheckAppend)
 			},
 		},
+		{
+			subdir: "all_enabled",
+			configFn: func(config *Configuration) {
+				config.Checks = AllChecks()
+				config.CaseMaxLines = 1
+			},
+		},
+		{
+			subdir: "newline_after_block",
+			configFn: func(config *Configuration) {
+				config.Checks = NoChecks()
+				config.Checks.Add(CheckCaseTrailingNewline)
+				config.Checks.Add(CheckNewlineAfterBlock)
+
+				config.CaseMaxLines = 1
+			},
+		},
 	} {
 		t.Run(tc.subdir, func(t *testing.T) {
 			t.Parallel()

config.go

@@ -70,6 +70,7 @@ const (
 	CheckErr
 	CheckLeadingWhitespace
 	CheckTrailingWhitespace
+	CheckNewlineAfterBlock
 
 	//nolint:godoclint // No need to document
 	// CheckTypes only used for reporting.
@@ -102,6 +103,7 @@ func (c CheckType) String() string {
 		"err",
 		"leading-whitespace",
 		"trailing-whitespace",
+		"newline-after-block",
 		//
 		"case-trailing-newline",
 	}[c]
@@ -211,6 +213,7 @@ func AllChecks() CheckSet {
 	c := DefaultChecks()
 	c.Add(CheckAssignExclusive)
 	c.Add(CheckAssignExpr)
+	c.Add(CheckNewlineAfterBlock)
 
 	return c
 }
@@ -274,6 +277,8 @@ func CheckFromString(s string) (CheckType, error) {
 		return CheckLeadingWhitespace, nil
 	case "trailing-whitespace":
 		return CheckTrailingWhitespace, nil
+	case "newline-after-block":
+		return CheckNewlineAfterBlock, nil
 	default:
 		return CheckInvalid, fmt.Errorf("invalid check '%s'", s)
 	}

config_test.go

@@ -83,7 +83,7 @@ func TestCheckSet(t *testing.T) {
 func TestToAndFromString(t *testing.T) {
 	t.Parallel()
 
-	maxCheckNumber := 23
+	maxCheckNumber := 24
 
 	for n := range maxCheckNumber {
 		check := CheckType(n)

testdata/src/default_config/whitespace/leading_whitespace.go

@@ -25,6 +25,26 @@ func commentThenLeadingWhitespace() { // want +2 `unnecessary whitespace \(leadi
 	fmt.Println("Hello, World")
 }
 
+// want +3 `unnecessary whitespace \(leading-whitespace\)`
+// want +4 `unnecessary whitespace \(leading-whitespace\)`
+func whitespaceBeforeAndAfterComment() {
+
+	// Whitespace before and after comment
+
+	fmt.Println("Hello, World")
+}
+
+// want +3 `unnecessary whitespace \(leading-whitespace\)`
+// want +6 `unnecessary whitespace \(leading-whitespace\)`
+func whitespaceBeforeAndAfterMultpleComment() {
+
+	// Whitespace before and after comment
+
+	// Some more comments
+
+	fmt.Println("Hello, World")
+}
+
 func noWhitespace() {
 	fmt.Println("Hello, World")
 }

testdata/src/default_config/whitespace/leading_whitespace.go.golden

@@ -22,6 +22,22 @@ func commentThenLeadingWhitespace() { // want +2 `unnecessary whitespace \(leadi
 	fmt.Println("Hello, World")
 }
 
+// want +3 `unnecessary whitespace \(leading-whitespace\)`
+// want +4 `unnecessary whitespace \(leading-whitespace\)`
+func whitespaceBeforeAndAfterComment() {
+	// Whitespace before and after comment
+	fmt.Println("Hello, World")
+}
+
+// want +3 `unnecessary whitespace \(leading-whitespace\)`
+// want +6 `unnecessary whitespace \(leading-whitespace\)`
+func whitespaceBeforeAndAfterMultpleComment() {
+	// Whitespace before and after comment
+
+	// Some more comments
+	fmt.Println("Hello, World")
+}
+
 func noWhitespace() {
 	fmt.Println("Hello, World")
 }