formatter: avoid hanging errorf calls

Remove the fmt.Errorf-only continuation-line shortcut.

Let error formatting use the same greedy path as other printf calls.

Update regressions to require packed heads without hanging parens.

Author: bhandras

cmd/llformat/main.go

@@ -254,9 +254,8 @@ func buildPipelineConfig(f cliFlags) (formatter.PipelineConfig, error) {
 	fixpointIters := f.fixpointIters
 	if fixpointIters < 0 {
 		return formatter.PipelineConfig{},
-			fmt.Errorf(
-				"invalid flags: --fixpoint-iters must be >= 0",
-			)
+			fmt.Errorf("invalid flags: --fixpoint-iters must be " +
+				">= 0")
 	}
 	if fixpointIters == 0 {
 		fixpointIters = 3

dsl/replace.go

@@ -8,9 +8,8 @@ import "fmt"
 func replaceSpan(src []byte, start, end int, replace []byte) ([]byte, error) {
 	if start < 0 || end < 0 || start > len(src) || end > len(src) ||
 		start >= end {
-		return nil, fmt.Errorf(
-			"invalid span [%d:%d] (len=%d)", start, end, len(src),
-		)
+		return nil, fmt.Errorf("invalid span [%d:%d] (len=%d)", start,
+			end, len(src))
 	}
 
 	return ApplySingleEdit(src, start, end, replace)

formatter/compact_call_formatter.go

@@ -2498,15 +2498,6 @@ func formatCallGreedyWithOptions(call []byte, wsIndent string, baseLen int,
 		advanceCols(baseLen, candidate) <= width {
 		return candidate
 	}
-	if head == "fmt.Errorf" {
-		if formatted, ok := formatCallArgsOnContinuationLine(
-			head, normArgs, wsIndent, contIndent, width,
-			hasInlineComment,
-		); ok {
-			return formatted
-		}
-	}
-
 	writeSplit := func(seg string, hasTrailingArgs bool) {
 		q := quoteGoString(seg)
 		b.WriteString(q)
@@ -2881,39 +2872,6 @@ func formatCallSingleLineCandidate(head string, args []arg,
 	return head + "(" + strings.Join(parts, ", ") + ")", true
 }
 
-func formatCallArgsOnContinuationLine(head string, args []arg, wsIndent,
-	contIndent string, width int, hasInlineComment bool) (string, bool) {
-
-	if hasInlineComment || len(args) == 0 {
-		return "", false
-	}
-
-	parts := make([]string, 0, len(args))
-	for _, a := range args {
-		switch a.kind {
-		case argText:
-			parts = append(parts, quoteGoString(a.text))
-
-		case argExpr:
-			expr := strings.TrimSpace(a.expr)
-			if expr == "" || strings.Contains(expr, "\n") {
-				return "", false
-			}
-			parts = append(parts, expr)
-
-		default:
-			return "", false
-		}
-	}
-
-	argLine := strings.Join(parts, ", ") + ","
-	if advanceCols(visualLen(contIndent), argLine) > width {
-		return "", false
-	}
-
-	return head + "(\n" + contIndent + argLine + "\n" + wsIndent + ")", true
-}
-
 func normalizeCallArgs(rawArgs []string, opts greedyCallOptions) []arg {
 	normArgs := make([]arg, 0, len(rawArgs))
 	rawCount := len(rawArgs)

formatter/compact_call_formatter_test.go

@@ -331,13 +331,14 @@ func TestFormatCallPackedMultiLine_DoesNotReflowNestedSlogAttrWhenItFits(
 	requireNoLineLongerThan(t, out, 80)
 }
 
-func TestFormatCallGreedy_DoesNotSplitShortFormatStringToFitCommaSpace(
+func TestFormatCallGreedy_BreaksBeforeTrailingArgForShortFormatString(
 	t *testing.T) {
 
 	// Regression test for "early break" in deeply indented return
-	// statements: when the whole call cannot fit on the current line, but
-	// the short argument list fits on a continuation line, prefer a
-	// multiline call over splitting the string into `"..." +\n"...", err`.
+	// statements: when the whole call cannot fit on the current line, keep
+	// the call head packed and break before the trailing arg instead of
+	// using a hanging-paren layout or splitting a short format string into
+	// `"..." +\n"...", err`.
 	call := []byte(`fmt.Errorf("error parsing psbt: %w", err)`)
 
 	// Choose a baseLen such that the quoted format string ends at column
@@ -350,9 +351,10 @@ func TestFormatCallGreedy_DoesNotSplitShortFormatStringToFitCommaSpace(
 	// 24 == 79 => curLen == 55 => baseLen == 44.
 	out := FormatCallGreedy(call, "\t\t\t\t\t", 44, 80, 8)
 
-	require.Contains(t, out, "fmt.Errorf(\n")
+	require.Contains(t, out, "fmt.Errorf(\"error parsing psbt: %w\",\n")
 	require.Contains(t, out, "\n					"+
-		"	\"error parsing psbt: %w\", err,")
+		"	err)")
+	require.NotContains(t, out, "fmt.Errorf(\n")
 	require.NotContains(
 		t, out, "\" +\n", "must not split a short format string "+
 			"just to make room for a following space",

formatter/pipeline_logcalls_next_test.go

@@ -438,7 +438,7 @@ func f() error {
 	require.NotContains(t, out, `"nil Message in " +`)
 }
 
-func TestPipelineNext_LogCalls_ShortConcatUsesMultilineCallWhenIndented(
+func TestPipelineNext_LogCalls_ShortConcatSplitsStringWhenIndented(
 	t *testing.T) {
 
 	const in = `package p
@@ -472,15 +472,16 @@ func f(msg any) error {
 	out := string(p.Format([]byte(in)))
 
 	require.Contains(
-		t, out, "return "+
-			"fmt.Errorf(\n				\"nil "+
-			"Message in "+
-			"SendServerEventRequest\",\n			)",
+		t, out, "return fmt.Errorf(\"nil Message in \" "+
+			"+"+
+			"\n"+
+			"				\"SendServerEventReq"+
+			"uest\")",
 	)
-	require.NotContains(t, out, `"nil Message in " +`)
+	require.NotContains(t, out, "return fmt.Errorf(\n")
 }
 
-func TestPipelineNext_LogCalls_ShortErrorfArgsUseMultilineCallWhenIndented(
+func TestPipelineNext_LogCalls_ShortErrorfArgsBreakBeforeArgWhenIndented(
 	t *testing.T) {
 
 	const in = `package p
@@ -512,11 +513,10 @@ func f(err error) (any, error) {
 	out := string(p.Format([]byte(in)))
 
 	require.Contains(
-		t, out, "return nil, "+
-			"fmt.Errorf(\n				\"control "+
-			"block to bytes: %w\", err,\n			)",
+		t, out, "return nil, fmt.Errorf(\"control block to bytes: "+
+			"%w\",\n				err)",
 	)
-	require.NotContains(t, out, `"control block to bytes: %w",`+"\n")
+	require.NotContains(t, out, "return nil, fmt.Errorf(\n")
 }
 
 func TestPipelineNext_LogCalls_ShortErrorfArgsStaySingleLineWhenTheyFit(
@@ -597,6 +597,44 @@ func nodeMaxDepth(depth int) (int, error) {
 	)
 }
 
+func TestPipelineNext_LogCalls_SplitsReturnErrorfWithoutHangingParen(
+	t *testing.T) {
+
+	const in = `package p
+
+import "fmt"
+
+func sum(inputs []Input) (int, error) {
+	for i := range inputs {
+		input := inputs[i]
+		if input.Amount <= 0 {
+			return 0, fmt.Errorf("input %d amount must be "+
+				"positive", i)
+		}
+	}
+
+	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.NotContains(t, out, "fmt.Errorf(\n")
+	requireNoLineLongerThan(t, out, 80)
+}
+
 func TestPipelineNext_LogCalls_FormatCompositeArgAsBlock(t *testing.T) {
 	const in = `package p
 

formatter/stage.go

@@ -79,9 +79,8 @@ func buildStageMap(stages []Stage) (map[string]Stage, []string, error) {
 			return nil, nil, fmt.Errorf("stage with empty name")
 		}
 		if _, exists := stageMap[s.Name]; exists {
-			return nil, nil, fmt.Errorf(
-				"duplicate stage name: %q", s.Name,
-			)
+			return nil, nil, fmt.Errorf("duplicate stage name: %q",
+				s.Name)
 		}
 		stageMap[s.Name] = s
 		order = append(order, s.Name)

tools/corpus_check/main.go

@@ -247,20 +247,17 @@ func buildReport(repos []string, cfg reportConfig) (report, error) {
 	for _, repoArg := range repos {
 		root, err := filepath.Abs(repoArg)
 		if err != nil {
-			return report{}, fmt.Errorf(
-				"resolve repo %q: %w", repoArg, err,
-			)
+			return report{}, fmt.Errorf("resolve repo %q: %w",
+				repoArg, err)
 		}
 		info, err := os.Stat(root)
 		if err != nil {
-			return report{}, fmt.Errorf(
-				"stat repo %q: %w", root, err,
-			)
+			return report{}, fmt.Errorf("stat repo %q: %w", root,
+				err)
 		}
 		if !info.IsDir() {
-			return report{}, fmt.Errorf(
-				"repo %q is not a directory", root,
-			)
+			return report{}, fmt.Errorf("repo %q is not a "+
+				"directory", root)
 		}
 
 		summary, cases, err := analyzeRepo(root, cfg)
@@ -782,9 +779,8 @@ func runLLFormat(llformatBin string, col, tabStop int, commentMode string,
 	}
 	var ee *exec.ExitError
 	if errors.As(err, &ee) {
-		return nil, fmt.Errorf(
-			"%w: %s", err, strings.TrimSpace(string(ee.Stderr)),
-		)
+		return nil, fmt.Errorf("%w: %s", err,
+			strings.TrimSpace(string(ee.Stderr)))
 	}
 
 	return nil, err

tools/overflow_report/main.go

@@ -686,9 +686,8 @@ func runLLFormat(llformatBin string, col, tabStop int,
 	}
 	var ee *exec.ExitError
 	if errors.As(err, &ee) {
-		return nil, fmt.Errorf(
-			"%w: %s", err, strings.TrimSpace(string(ee.Stderr)),
-		)
+		return nil, fmt.Errorf("%w: %s", err,
+			strings.TrimSpace(string(ee.Stderr)))
 	}
 
 	return nil, err
@@ -813,9 +812,8 @@ func extractSnippets(originalPath string, formatted []byte,
 	}
 	tf := fset.File(f.Pos())
 	if tf == nil {
-		return make([]snippet, len(overflows)), fmt.Errorf(
-			"missing token.File for %s", originalPath,
-		)
+		return make([]snippet, len(overflows)), fmt.Errorf("missing "+
+			"token.File for %s", originalPath)
 	}
 
 	out := make([]snippet, 0, len(overflows))