formatter: preserve readable call args

Parse greedy call arguments with brace awareness so composite literal
arguments keep their block shape. This avoids treating map entries as
separate call arguments and keeps the closing brace on its own line.

Keep the argument following a multiline expression on a fresh line. Also
preserve explicit string concatenation when a line-oriented or deeply
indented string would otherwise fragment into tiny pieces.

Allow the CLI to format multiple files in one -w invocation. Adoption
Makefiles can now pass batched xargs input without spawning one process
per file.

Author: bhandras

cmd/llformat/main.go

@@ -127,27 +127,47 @@ func run(args []string, stdout, stderr io.Writer) int {
 		return runPrintLogCallsPatterns(stdout, cfg)
 	}
 
-	if fs.NArg() != 1 {
+	if fs.NArg() == 0 {
 		fs.Usage()
 
 		return 2
 	}
 
-	path := fs.Arg(0)
-	data, err := os.ReadFile(path)
-	if err != nil {
-		fmt.Fprintf(stderr, "read %s: %v\n", path, err)
+	paths := fs.Args()
+	if !f.write && len(paths) != 1 {
+		fmt.Fprintln(
+			stderr, "llformat: multiple paths require -w/--write",
+		)
+		fs.Usage()
 
-		return 1
+		return 2
 	}
 
-	out := formatter.NewPipeline(cfg).Format(data)
+	p := formatter.NewPipeline(cfg)
+	for _, path := range paths {
+		data, err := os.ReadFile(path)
+		if err != nil {
+			fmt.Fprintf(stderr, "read %s: %v\n", path, err)
 
-	if f.write {
-		return writeOutputToFile(path, out, stderr)
+			return 1
+		}
+
+		out := p.Format(data)
+
+		if f.write {
+			if code := writeOutputToFile(
+				path, out, stderr,
+			); code != 0 {
+				return code
+			}
+
+			continue
+		}
+
+		return writeOutputToWriter(out, stdout)
 	}
 
-	return writeOutputToWriter(out, stdout)
+	return 0
 }
 
 func printUsage(w io.Writer) {
@@ -160,7 +180,7 @@ func printUsage(w io.Writer) {
 			"FUNCS] [--logcalls-min-tail-len N] "+
 			"[--logcalls-selector-names NAMES] "+
 			"[--logcalls-selector-prefixes PREFIXES] "+
-			"[--fixpoint-iters N] <path>",
+			"[--fixpoint-iters N] <path> [path ...]",
 	)
 	fmt.Fprintln(w, "  llformat --print-plan")
 	fmt.Fprintln(w, "  llformat --print-logcalls-patterns")

cmd/llformat/main_test.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestRunWriteMultiplePaths(t *testing.T) {
+	dir := t.TempDir()
+	paths := []string{
+		filepath.Join(dir, "one.go"),
+		filepath.Join(dir, "two.go"),
+	}
+	src := []byte(`package p
+
+import "fmt"
+
+func f() error {
+	return fmt.Errorf("this is a deliberately long error message that should split")
+}
+`)
+
+	for _, path := range paths {
+		require.NoError(t, os.WriteFile(path, src, 0o600))
+	}
+
+	var stdout, stderr bytes.Buffer
+	code := run(
+		[]string{"-w", "--col", "50", paths[0], paths[1]}, &stdout,
+		&stderr,
+	)
+
+	require.Equal(t, 0, code, stderr.String())
+	require.Empty(t, stdout.String())
+	for _, path := range paths {
+		got, err := os.ReadFile(path)
+		require.NoError(t, err)
+		require.Contains(t, string(got), "\"this is a \" +")
+		require.Contains(
+			t, string(got),
+			"\"deliberately long error \" +",
+		)
+	}
+}
+
+func TestRunMultiplePathsRequireWrite(t *testing.T) {
+	dir := t.TempDir()
+	one := filepath.Join(dir, "one.go")
+	two := filepath.Join(dir, "two.go")
+	require.NoError(t, os.WriteFile(one, []byte("package p\n"), 0o600))
+	require.NoError(t, os.WriteFile(two, []byte("package p\n"), 0o600))
+
+	var stdout, stderr bytes.Buffer
+	code := run([]string{one, two}, &stdout, &stderr)
+
+	require.Equal(t, 2, code)
+	require.Empty(t, stdout.String())
+	require.Contains(
+		t, stderr.String(),
+		"multiple paths require -w/--write",
+	)
+}

dsl/expr_doc.go

@@ -558,7 +558,8 @@ func methodChainSegmentDoc(seg segment, ctx *Context,
 				layout.L(), layout.C(brokenArgs...),
 				layout.T(","),
 			),
-		), layout.L(),
+		),
+		layout.L(),
 	)
 
 	// In flat mode, keep args inline. In broken mode, put each arg on its
@@ -690,7 +691,8 @@ func parenExprDoc(p *ast.ParenExpr, ctx *Context) (layout.Doc, bool) {
 						layout.SL(), inner,
 					),
 				),
-			), layout.T(")"),
+			),
+			layout.T(")"),
 		),
 	), true
 }
@@ -889,7 +891,8 @@ func logicalBinaryExprDoc(bin *ast.BinaryExpr, ctx *Context,
 			left, layout.T(" "),
 			layout.T(
 				bin.Op.String(),
-			), layout.L(),
+			),
+			layout.L(),
 			right,
 		),
 	), true
@@ -941,7 +944,8 @@ func comparisonBinaryExprDoc(bin *ast.BinaryExpr, ctx *Context,
 			leftDoc, layout.T(" "),
 			layout.T(
 				bin.Op.String(),
-			), layout.SL(),
+			),
+			layout.SL(),
 			rightDoc,
 		),
 	), true
@@ -1034,7 +1038,8 @@ func indexExprDoc(idx *ast.IndexExpr, ctx *Context,
 						layout.SL(), indexDoc,
 					),
 				),
-			), layout.T("]"),
+			),
+			layout.T("]"),
 		),
 	), true
 }
@@ -1189,7 +1194,8 @@ func typeAssertExprDoc(t *ast.TypeAssertExpr, ctx *Context,
 						layout.SL(), typeDoc,
 					),
 				),
-			), layout.T(")"),
+			),
+			layout.T(")"),
 		),
 	), true
 }
@@ -1271,7 +1277,8 @@ func sliceExprDoc(s *ast.SliceExpr, ctx *Context,
 						layout.SL(), inner,
 					),
 				),
-			), layout.T("]"),
+			),
+			layout.T("]"),
 		),
 	), true
 }

dsl/layout/render_test.go

@@ -49,7 +49,8 @@ func TestRenderAlignIndentsToCurrentColumn(t *testing.T) {
 				C(
 					T("a,"), L(), T("b,"), L(), T("c"),
 				),
-			), T(")"),
+			),
+			T(")"),
 		),
 	)
 	out := Render(doc, 7, 8, "")

formatter/compact_call_formatter.go

@@ -971,7 +971,7 @@ func formatCallPackedMultiLine(call []byte, wsIndent, fullPrefix string,
 		// []string{" in Configure)
 		shouldBreakAfterCall := seenMultilineCall
 		shouldBreakAfterComposite := seenMultilineComposite &&
-			!seenMultilineCall && !argIsMultiline
+			!seenMultilineCall
 		shouldBreak := curLen+need > lineWidth || forcedBreak ||
 			shouldBreakAfterCall || shouldBreakAfterComposite
 		if shouldBreak {
@@ -1531,13 +1531,14 @@ func formatCallPackedMultiLineNext(call []byte, wsIndent, fullPrefix string,
 
 		// Handle call expression arguments with potential nesting.
 		callState := &callExprArgNextState{
-			b:                      &b,
-			contIndent:             contIndent,
-			contIndentLen:          contIndentLen,
-			lineWidth:              lineWidth,
-			curLen:                 curLen,
-			first:                  first,
-			forcedBreak:            forcedBreak,
+			b:             &b,
+			contIndent:    contIndent,
+			contIndentLen: contIndentLen,
+			lineWidth:     lineWidth,
+			curLen:        curLen,
+			first:         first,
+			forcedBreak: forcedBreak || (!first &&
+				(seenMultilineCall || seenMultilineComposite)),
 			seenMultilineCall:      seenMultilineCall,
 			seenMultilineComposite: seenMultilineComposite,
 		}
@@ -1955,6 +1956,10 @@ func (s *callExprArgNextState) writeArgSimple(a string) {
 		s.b.WriteString(s.contIndent)
 		s.b.WriteString(a)
 		s.curLen = s.contIndentLen + firstLineLen(a)
+		if strings.Contains(a, "\n") {
+			s.curLen = lastLineLen(a)
+			s.seenMultilineCall = true
+		}
 		s.first = false
 
 		return
@@ -1970,6 +1975,10 @@ func (s *callExprArgNextState) writeArgSimple(a string) {
 	}
 	s.b.WriteString(a)
 	s.curLen = advanceCols(s.curLen+2, a)
+	if strings.Contains(a, "\n") {
+		s.curLen = lastLineLen(a)
+		s.seenMultilineCall = true
+	}
 }
 
 func formatSelectorCallArgIfOverflowsNext(arg, contIndent string,
@@ -2421,7 +2430,7 @@ func formatCallGreedyWithOptions(call []byte, wsIndent string, baseLen int,
 
 	// No pre-scan; we will attach leading comments of the next arg (// or
 	// /* */) to the previous argument inline when emitting.
-	rawArgs := scanner.SplitTopLevel(argsBody)
+	rawArgs := scanner.SplitTopLevelAny(argsBody)
 	hasInlineComment := strings.Contains(argsBody, "/*") ||
 		strings.Contains(argsBody, "//")
 	normArgs := normalizeCallArgs(rawArgs, opts)
@@ -2432,6 +2441,15 @@ func formatCallGreedyWithOptions(call []byte, wsIndent string, baseLen int,
 	b.WriteByte('(')
 	curLen := baseLen + visualLen(head) + 1
 	contIndent := wsIndent + "\t"
+	prevArgMultiline := false
+
+	if len(normArgs) == 1 && normArgs[0].kind == argText {
+		q := quoteGoString(normArgs[0].text)
+		candidate := head + "(" + q + ")"
+		if advanceCols(baseLen, candidate) <= width {
+			return candidate
+		}
+	}
 
 	writeSplit := func(seg string, hasTrailingArgs bool) {
 		q := quoteGoString(seg)
@@ -2474,7 +2492,12 @@ func formatCallGreedyWithOptions(call []byte, wsIndent string, baseLen int,
 					a.expr,
 				)
 			}
-			if hasInlineComment {
+			if prevArgMultiline {
+				curLen = emitBreakWithComments(
+					&b, prefixes, contIndent,
+				)
+				justBroke = true
+			} else if hasInlineComment {
 				// Separator on same line; attach trailing line
 				// comment to previous arg, then place any block
 				// comment before next arg.
@@ -2541,10 +2564,19 @@ func formatCallGreedyWithOptions(call []byte, wsIndent string, baseLen int,
 			curLen = writeExprArg(
 				&b, a.expr, wsIndent, curLen, opts,
 			)
+			prevArgMultiline = strings.Contains(a.expr, "\n")
 			continue
 		}
 
 		// String arg: split greedily
+		if shouldPreserveExplicitStringConcat(a, contIndent, width) {
+			b.WriteString(a.raw)
+			curLen = advanceCols(curLen, a.raw)
+			prevArgMultiline = strings.Contains(a.raw, "\n")
+
+			continue
+		}
+
 		rest := a.text
 		hasTrailingArgs := i < len(normArgs)-1
 		avoidTinyVerbTail := opts.AvoidTinyFormatVerbTail &&
@@ -2746,6 +2778,7 @@ func formatCallGreedyWithOptions(call []byte, wsIndent string, baseLen int,
 			writeSplit(seg, hasTrailingArgs)
 			rest = rest[cut+1:]
 		}
+		prevArgMultiline = false
 	}
 	b.WriteByte(')')
 
@@ -2827,13 +2860,32 @@ func normalizeCallArg(trimmed string, argIndex int, rawCount int,
 	}
 
 	return arg{
-		kind:               argText,
-		text:               str,
-		raw:                trimmed,
-		containsFormatVerb: containsFormatVerb(str),
+		kind:                 argText,
+		text:                 str,
+		raw:                  trimmed,
+		containsFormatVerb:   containsFormatVerb(str),
+		explicitStringConcat: !isBasicStringLitExpr(e),
 	}
 }
 
+func shouldPreserveExplicitStringConcat(a arg, contIndent string,
+	width int) bool {
+
+	if !a.explicitStringConcat {
+		return false
+	}
+	if strings.Contains(a.text, "\n") {
+		return true
+	}
+
+	// Deeply indented calls can leave too little room for useful word
+	// splits. In that case, keep the author's concatenation boundaries
+	// instead of hard-cutting tiny string fragments.
+	const minUsefulTextCols = 24
+
+	return width-visualLen(contIndent)-4 < minUsefulTextCols
+}
+
 type argKind int
 
 const (
@@ -2847,7 +2899,8 @@ type arg struct {
 	text string
 	raw  string
 
-	containsFormatVerb bool
+	containsFormatVerb   bool
+	explicitStringConcat bool
 }
 
 // commentPrefixes holds extracted comment prefixes from an argument.
@@ -3162,6 +3215,14 @@ func tryMoveStringToCont(b *strings.Builder, q, contIndent string, curLen *int,
 func writeExprArg(b *strings.Builder, expr, wsIndent string, curLen int,
 	opts greedyCallOptions) int {
 
+	if formatted, ok := FormatCompositeLiteralArg(
+		expr, wsIndent+"\t",
+	); ok && strings.Contains(formatted, "\n") {
+
+		b.WriteString(formatted)
+
+		return lastLineLen(formatted)
+	}
 	if isTargetedCallStart(expr) {
 		formatted := formatCallGreedyWithOptions(
 			[]byte(expr), wsIndent, curLen, opts,