formatter: separate select case clauses

Treat select communication clauses like switch case clauses in the blank-line pass so separator blanks appear between clauses rather than inside the clause header. Suppress blank-before-return insertion when a case or select clause contains only a return statement, even when that return has a leading comment. Add a regression test for select clauses that keeps the first case compact, separates the next case, and preserves the existing blank-before-return behavior for a multi-statement final case.

Author: bhandras

dsl/action.go

@@ -5194,6 +5194,12 @@ func (c *blankLineBatchContext) inspectFile(file *ast.File) {
 					c.maybeInsertBlankBefore(n)
 				}
 
+			case *ast.CommClause:
+				c.maybeRemoveBlankAfterSingleLineBlockHeader(n)
+				if c.caseCond.Eval(caps, c.ctx) {
+					c.maybeInsertBlankBefore(n)
+				}
+
 			case *ast.ReturnStmt:
 				if onlyStmtInBlockWithoutLeadingComment(
 					c.ctx, n,
@@ -5275,6 +5281,14 @@ func (c *blankLineBatchContext) maybeRemoveBlankAfterSingleLineBlockHeader(
 		headerStart = c.ctx.Fset.Position(n.Pos())
 		headerEnd = c.ctx.Fset.Position(n.Colon)
 
+	case *ast.CommClause:
+		if n == nil || len(n.Body) == 0 {
+			return
+		}
+		first = n.Body[0]
+		headerStart = c.ctx.Fset.Position(n.Pos())
+		headerEnd = c.ctx.Fset.Position(n.Colon)
+
 	default:
 		return
 	}

dsl/condition.go

@@ -1103,8 +1103,8 @@ func (c *IsFinalReturnCond) Eval(caps Captures, ctx *Context) bool {
 	}
 }
 
-// HasPrecedingSiblingCond checks if a case clause has a preceding sibling case.
-// Used to determine if blank line is needed before a case.
+// HasPrecedingSiblingCond checks if a switch/select clause has a preceding
+// sibling clause. Used to determine if a blank line is needed before a clause.
 type HasPrecedingSiblingCond struct {
 	Target string
 }
@@ -1116,8 +1116,10 @@ func (c *HasPrecedingSiblingCond) Eval(caps Captures, ctx *Context) bool {
 		return false
 	}
 
-	caseClause, ok := node.(*ast.CaseClause)
-	if !ok {
+	switch node.(type) {
+	case *ast.CaseClause, *ast.CommClause:
+
+	default:
 		return false
 	}
 
@@ -1133,9 +1135,9 @@ func (c *HasPrecedingSiblingCond) Eval(caps Captures, ctx *Context) bool {
 		return false
 	}
 
-	// Find this case in the block's statements
+	// Find this clause in the block's statements.
 	for i, stmt := range blockStmt.List {
-		if stmt == caseClause {
+		if stmt == node {
 			return i > 0 // Has preceding sibling if not first
 		}
 	}
@@ -2115,6 +2117,9 @@ func (c *IsReturnNeedingBlankCond) Eval(caps Captures, ctx *Context) bool {
 	if !ok {
 		return false
 	}
+	if onlyStmtInClause(ctx, node) {
+		return false
+	}
 	if onlyStmtInBlockWithoutLeadingComment(ctx, node) {
 		return false
 	}
@@ -2167,6 +2172,21 @@ func (c *IsReturnNeedingBlankCond) Eval(caps Captures, ctx *Context) bool {
 	return true
 }
 
+func onlyStmtInClause(ctx *Context, node ast.Node) bool {
+	switch parent := ctx.Parent(node).(type) {
+	case *ast.CaseClause:
+		return parent != nil && len(parent.Body) == 1 &&
+			parent.Body[0] == node
+
+	case *ast.CommClause:
+		return parent != nil && len(parent.Body) == 1 &&
+			parent.Body[0] == node
+
+	default:
+		return false
+	}
+}
+
 func onlyStmtInBlockWithoutLeadingComment(ctx *Context, node ast.Node) bool {
 	block, ok := ctx.Parent(node).(*ast.BlockStmt)
 	if !ok || block == nil || len(block.List) != 1 ||

dsl/rules.go

@@ -921,6 +921,23 @@ func BlankLineRulesWithOptions(opts BlankLineOptions) []Rule {
 				Target: "node",
 			},
 		},
+		{
+			Name: "blank_before_comm_clause",
+			Pattern: &NodePattern{
+				Type: "CommClause",
+			},
+			When: &AndCond{
+				Conds: []Condition{
+					&HasPrecedingSiblingCond{
+						Target: "node",
+					},
+				},
+			},
+			Priority: 10,
+			Action: &InsertBlankBeforeAction{
+				Target: "node",
+			},
+		},
 
 		// Rule: Blank line before return (if not after block open or
 		// case:)

formatter/pipeline_dsl_blanklines_extras_test.go

@@ -169,6 +169,57 @@ func record() {}
 	require.NoError(t, err)
 }
 
+func TestDSLBlankLinesNative_SelectCasesSeparateClausesNotHeaders(
+	t *testing.T) {
+
+	const in = `package p
+
+import "context"
+
+func f(ctx context.Context, done chan struct{}) error {
+	select {
+	case <-done:
+		// Work completed.
+		return nil
+	case <-ctx.Done():
+		// Context cancelled before work finished.
+		close(done)
+		return ctx.Err()
+	}
+}
+`
+
+	p := NewPipeline(
+		PipelineConfig{
+			ColumnLimit:            80,
+			TabStop:                8,
+			UseDSLBlankLines:       true,
+			UseDSLBlankLinesNative: true,
+		},
+	)
+
+	first := p.Format([]byte(in))
+	second := p.Format(first)
+	require.Equal(t, string(first), string(second))
+
+	out := string(first)
+	require.Contains(
+		t, out, "case <-done:\n		// Work "+
+			"completed.\n		return nil\n\n	case "+
+			"<-ctx.Done():",
+	)
+	require.Contains(
+		t, out,
+		"close(done)\n\n\t\treturn ctx.Err()\n\t}",
+	)
+	require.NotContains(t, out, "case <-done:\n\n		// Work "+
+		"completed.")
+
+	fset := token.NewFileSet()
+	_, err := parser.ParseFile(fset, "out.go", first, parser.AllErrors)
+	require.NoError(t, err)
+}
+
 func TestDSLBlankLinesNative_DoesNotBlankBeforeOnlyWrappedReturn(t *testing.T) {
 	const in = `package p