formatter: trim single-line block spacers

Single-line block headers should not keep a blank before their first
real statement. Extend the blank-line batch pass to remove stale
spacers for if, for, range, and case bodies while leaving multiline
headers alone.

Preserve leading-comment spacing and let the existing sole-return
cleanup own return-only blocks. Add a regression that keeps t.Fatalf
packed while removing the screenshot-shaped extra blank.

Author: bhandras

dsl/action.go

@@ -5103,6 +5103,7 @@ func (c *blankLineBatchContext) inspectFile(file *ast.File) {
 			caps := Captures{"node": n}
 			switch n.(type) {
 			case *ast.CaseClause:
+				c.maybeRemoveBlankAfterSingleLineBlockHeader(n)
 				if c.caseCond.Eval(caps, c.ctx) {
 					c.maybeInsertBlankBefore(n)
 				}
@@ -5128,19 +5129,91 @@ func (c *blankLineBatchContext) inspectFile(file *ast.File) {
 				}
 
 			case *ast.IfStmt:
+				c.maybeRemoveBlankAfterSingleLineBlockHeader(n)
 				if c.opts.ExtraIfErrReturn && c.ifErrReturnCond.Eval(
 					caps, c.ctx,
 				) {
 
 					c.maybeInsertBlankBefore(n)
 				}
+
+			case *ast.ForStmt:
+				c.maybeRemoveBlankAfterSingleLineBlockHeader(n)
+
+			case *ast.RangeStmt:
+				c.maybeRemoveBlankAfterSingleLineBlockHeader(n)
 			}
 
 			return true
 		},
 	)
 }
 
+func (c *blankLineBatchContext) maybeRemoveBlankAfterSingleLineBlockHeader(
+	node ast.Node) {
+
+	var first ast.Stmt
+	var headerStart token.Position
+	var headerEnd token.Position
+
+	switch n := node.(type) {
+	case *ast.IfStmt:
+		if n == nil || n.Body == nil || len(n.Body.List) == 0 {
+			return
+		}
+		first = n.Body.List[0]
+		headerStart = c.ctx.Fset.Position(n.Pos())
+		headerEnd = c.ctx.Fset.Position(n.Body.Lbrace)
+
+	case *ast.ForStmt:
+		if n == nil || n.Body == nil || len(n.Body.List) == 0 {
+			return
+		}
+		first = n.Body.List[0]
+		headerStart = c.ctx.Fset.Position(n.Pos())
+		headerEnd = c.ctx.Fset.Position(n.Body.Lbrace)
+
+	case *ast.RangeStmt:
+		if n == nil || n.Body == nil || len(n.Body.List) == 0 {
+			return
+		}
+		first = n.Body.List[0]
+		headerStart = c.ctx.Fset.Position(n.Pos())
+		headerEnd = c.ctx.Fset.Position(n.Body.Lbrace)
+
+	case *ast.CaseClause:
+		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
+	}
+
+	if headerStart.Line != headerEnd.Line {
+		return
+	}
+
+	if _, ok := first.(*ast.ReturnStmt); ok &&
+		onlyStmtInBlockWithoutLeadingComment(c.ctx, first) {
+		return
+	}
+
+	start := c.ctx.Fset.Position(first.Pos()).Offset
+	if start <= 0 || start > len(c.ctx.Source) {
+		return
+	}
+	lineStartIdx := lineStart(c.ctx.Source, start)
+	if leadingCommentBlockLineStart(c.ctx.Source, lineStartIdx) !=
+		lineStartIdx {
+		return
+	}
+	c.maybeRemoveBlankBeforeLineStart(lineStartIdx)
+}
+
 func (c *blankLineBatchContext) maybeRemoveBlankBeforeLineStart(
 	lineStartIdx int) {
 

dsl/string_literal_split_action.go

@@ -132,7 +132,6 @@ func buildSplitQuotedForCallArgDSL(text string, startCol int, wsIndent string,
 	}
 
 	for rest != "" {
-
 		// If indentation already exceeds the available width budget,
 		// splitting can't help.
 		if curStart >= colLimit {

formatter/pipeline_dsl_blanklines_extras_test.go

@@ -215,4 +215,51 @@ func f(i int, childIdx uint32) error {
 	require.NoError(t, err)
 }
 
+func TestDSLBlankLinesNative_RemovesBlankAfterSingleLineIfWithWrappedFatalf(
+	t *testing.T) {
+
+	const in = `package p
+
+import "testing"
+
+func f(t *testing.T, got, want []int) {
+	if len(got) != len(want) {
+
+		t.Fatalf("input_indices length mismatch: got %d want %d",
+			len(got), len(want))
+	}
+}
+`
+
+	p := NewPipeline(
+		PipelineConfig{
+			ColumnLimit:            80,
+			TabStop:                8,
+			UseDSLLogCalls:         true,
+			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, "if len(got) != len(want) "+
+			"{\n		t.Fatalf(\"input_indices length "+
+			"mismatch: got %d want %d\",",
+	)
+	require.Contains(t, out, "\n\t\t\tlen(got), len(want))")
+	require.NotContains(
+		t, out, "if len(got) != len(want) {\n\n		t.Fatalf(",
+	)
+	require.NotContains(t, out, "t.Fatalf(\n")
+
+	fset := token.NewFileSet()
+	_, err := parser.ParseFile(fset, "out.go", first, parser.AllErrors)
+	require.NoError(t, err)
+}
+
 // Note: legacy/parity profiles were removed; llformat is next-only.