formatter: preserve fitting formatted blocks

Keep already-multiline multi-argument fmt.Errorf calls unchanged when
all existing physical lines fit the configured column limit. This avoids
collapsing a deliberately split format string and argument back onto one
line just because the call target is printf-like.

Treat blank line comments as paragraph boundaries in conservative
overflow mode. A wrapped paragraph can still be fixed, but a separate
fitting paragraph after a `//` separator is preserved as its own unit.

Add synthetic regressions for both cases without relying on downstream
repository snippets.

Author: bhandras

dsl/action.go

@@ -2263,6 +2263,9 @@ func (a *LeftFlowCallAction) Execute(caps Captures, ctx *Context) ([]byte,
 
 	original := ctx.Source[start:end]
 	wsIndent := ctx.IndentAt(call)
+	if shouldPreserveFittingMultilineErrorf(ctx, call, start, end, original) {
+		return nil, false
+	}
 
 	// Find the base length (visual width from line start to call start).
 	baseLen := prefixWidthAt(ctx.Source, start, ctx.TabStop)
@@ -2315,6 +2318,23 @@ func (a *LeftFlowCallAction) Execute(caps Captures, ctx *Context) ([]byte,
 	return out, true
 }
 
+func shouldPreserveFittingMultilineErrorf(ctx *Context, call *ast.CallExpr,
+	start int, end int, original []byte) bool {
+
+	if callExprFuncNameFromExpr(call.Fun) != "fmt.Errorf" {
+		return false
+	}
+	if len(call.Args) < 2 {
+		return false
+	}
+	if !strings.Contains(string(original), "\n") {
+		return false
+	}
+
+	return maxVisualLineLenInSpan(ctx.Source, start, end, ctx.TabStop) <=
+		ctx.ColumnLimit
+}
+
 func callIsCompositeKeyValue(call *ast.CallExpr, ctx *Context) bool {
 	if call == nil || ctx == nil {
 		return false

formatter/comment_formatter_conservative_test.go

@@ -52,6 +52,42 @@ func f() {}
 	requireNoLineLongerThan(t, out, 48)
 }
 
+func TestCommentFormatterOverflowModeSplitsLineBlocksAtBlankComments(
+	t *testing.T) {
+
+	in := []byte(`package p
+
+// The queued value is persisted for crash recovery, but successful responses
+// are intentionally handled by the in-memory request path for this generic worker.
+// Returns an error if the claim has expired or belongs to another worker.
+//
+// The context should contain any transaction needed for atomic operations.
+// If a transaction is present, the update will be part of that
+// transaction.
+func f() {}
+`)
+
+	f := compat.NewCommentFormatter(
+		compat.CommentConfig{
+			ColumnLimit: 80,
+			Mode:        compat.CommentModeOverflow,
+		},
+	)
+	out := string(f.FormatFile(in))
+
+	require.Contains(
+		t, out, "// The context should contain any transaction "+
+			"needed for atomic operations.\n// If a "+
+			"transaction is present, the update will be part "+
+			"of that\n// transaction.",
+	)
+	require.NotContains(
+		t, out, "// The context should contain any transaction "+
+			"needed for atomic operations. If a",
+	)
+	requireNoLineLongerThan(t, out, 80)
+}
+
 func TestCommentFormatterOverflowModePreservesPreformattedBlocks(t *testing.T) {
 	in := []byte(`package p
 

formatter/pipeline_logcalls_next_test.go

@@ -555,6 +555,48 @@ func f(t *Tree) (*Path, error) {
 	require.NotContains(t, out, "fmt.Errorf(\n")
 }
 
+func TestPipelineNext_LogCalls_PreservesFittingMultilineErrorf(t *testing.T) {
+	const in = `package p
+
+import "fmt"
+
+const maxTreeDepth = 32
+
+func nodeMaxDepth(depth int) (int, error) {
+	if depth > maxTreeDepth {
+		return 0, fmt.Errorf(
+			"tree depth exceeds limit %d",
+			maxTreeDepth,
+		)
+	}
+
+	return 0, nil
+}
+`
+
+	p := NewPipeline(PipelineConfig{
+		ColumnLimit:    80,
+		TabStop:        8,
+		UseDSLLogCalls: true,
+		// Keep other DSL stages off to make this test focused.
+		UseDSLMultiLineCalls: false,
+		UseDSLExpr:           false,
+		UseDSLComments:       false,
+		UseDSLFuncSigs:       false,
+		UseDSLBlankLines:     false,
+	})
+
+	out := string(p.Format([]byte(in)))
+
+	require.Contains(
+		t, out, "\"tree depth exceeds limit "+
+			"%d\",\n			maxTreeDepth,",
+	)
+	require.NotContains(
+		t, out, "\"tree depth exceeds limit %d\", maxTreeDepth,",
+	)
+}
+
 func TestPipelineNext_LogCalls_FormatCompositeArgAsBlock(t *testing.T) {
 	const in = `package p
 

internal/compat/comment_formatter.go

@@ -958,12 +958,63 @@ func processLineCommentBlock(lines []string, i int, out []string) ([]string,
 		j++
 	}
 
+	if commentMode == CommentModeOverflow &&
+		lineCommentBlockHasBlank(block) {
+
+		reflowed := reflowLineCommentBlockByBlankBoundaries(
+			block, indent,
+		)
+		out = append(out, reflowed...)
+
+		return out, j, true
+	}
+
 	reflowed := reflowLineCommentBlock(block, indent)
 	out = append(out, reflowed...)
 
 	return out, j, true
 }
 
+func lineCommentBlockHasBlank(block []string) bool {
+	for _, line := range block {
+		if isBlankLineComment(line) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func isBlankLineComment(line string) bool {
+	return strings.TrimSpace(commentLineContent(line)) == ""
+}
+
+func reflowLineCommentBlockByBlankBoundaries(block []string,
+	indent string) []string {
+
+	var out []string
+	var segment []string
+	flush := func() {
+		if len(segment) == 0 {
+			return
+		}
+		out = append(out, reflowLineCommentBlock(segment, indent)...)
+		segment = nil
+	}
+
+	for _, line := range block {
+		if isBlankLineComment(line) {
+			flush()
+			out = append(out, line)
+			continue
+		}
+		segment = append(segment, line)
+	}
+	flush()
+
+	return out
+}
+
 // processBlockComment handles a standalone block comment starting at index i.
 // Returns the updated output slice, new index, and whether a block was
 // processed.