overflow: add report tool and reduce overflows

Author: bhandras

cmd/llformat/main.go

@@ -262,7 +262,8 @@ func runPrintLogCallsPatterns(w io.Writer, cfg formatter.PipelineConfig) int {
 		selectorNames = dsl.LogPrintfSelectorNames()
 	}
 	fmt.Fprintf(
-		w, "- printf-style selector names (effective): %s\n", strings.Join(
+		w, "- printf-style selector names (effective): %s\n",
+		strings.Join(
 			selectorNames, ", ",
 		),
 	)

formatter/compact_call_formatter_test.go

@@ -135,17 +135,16 @@ func TestFormatCallPackedMultiLineNext_BreaksBeforeMultilineCallArg(
 	out := FormatCallPackedMultiLineNext(call, "\t", 80, 8)
 
 	require.NotContains(
-		t, out,
-		"secondArgumentExtraYY, innerCallWithExtraLongName[",
+		t, out, "secondArgumentExtraYY, innerCallWithExtraLongName[",
 	)
 
 	for _, line := range strings.Split(out, "\n") {
 		if line == "" {
 			continue
 		}
 		require.LessOrEqual(
-			t, llwidth.VisualLenWithTab(line, 8), 80,
-			"line exceeds configured column limit: %q", line,
+			t, llwidth.VisualLenWithTab(line, 8), 80, "line "+
+				"exceeds configured column limit: %q", line,
 		)
 	}
 }

formatter/expression_formatter.go

@@ -68,6 +68,9 @@ func formatKeyedCompositeLiteral(before, contIndent string,
 	b.WriteString("{")
 	b.WriteByte('\n')
 	innerIndent := contIndent + "\t"
+	if shouldOutdentCompositeElems(contIndent, innerIndent, elems) {
+		innerIndent = contIndent
+	}
 
 	// Keyed literals (map/struct): one entry per line with trailing comma.
 	for _, e := range elems {
@@ -87,6 +90,52 @@ func formatKeyedCompositeLiteral(before, contIndent string,
 	return b.String()
 }
 
+func shouldOutdentCompositeElems(contIndent, innerIndent string,
+	elems []string) bool {
+
+	if visualLen(contIndent) >= visualLen(innerIndent) {
+		return false
+	}
+	maxInner := 0
+	maxOutdent := 0
+	for _, e := range elems {
+		t := strings.TrimSpace(e)
+		if t == "" {
+			continue
+		}
+		if l := maxLineLenWithIndentAndComma(t, innerIndent); l > maxInner {
+			maxInner = l
+		}
+		if l := maxLineLenWithIndentAndComma(t, contIndent); l > maxOutdent {
+			maxOutdent = l
+		}
+	}
+
+	return maxInner > columnLimit && maxOutdent <= columnLimit
+}
+
+func maxLineLenWithIndentAndComma(elem, indent string) int {
+	lines := strings.Split(elem, "\n")
+	if len(lines) == 0 {
+		return visualLen(indent) + 1
+	}
+	maxLen := 0
+	for i, line := range lines {
+		lineLen := visualLen(line)
+		if i == 0 {
+			lineLen += visualLen(indent)
+		}
+		if i == len(lines)-1 {
+			lineLen++
+		}
+		if lineLen > maxLen {
+			maxLen = lineLen
+		}
+	}
+
+	return maxLen
+}
+
 func formatSliceCompositeLiteral(arg, before, contIndent string,
 	elems []string) (string, bool) {
 

formatter/expression_formatter_test.go

@@ -0,0 +1,34 @@
+package formatter
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestFormatCompositeLiteralArg_OutdentsWhenIndentOverflow(t *testing.T) {
+	formatGlobalsMu.Lock()
+	oldColumnLimit := columnLimit
+	oldTabStop := tabStop
+	defer func() {
+		columnLimit = oldColumnLimit
+		tabStop = oldTabStop
+		formatGlobalsMu.Unlock()
+	}()
+
+	columnLimit = 40
+	tabStop = 8
+
+	arg := "Item{Index: int64(1)}"
+	contIndent := "\t\t\t"
+	out, ok := FormatCompositeLiteralArg(arg, contIndent)
+	require.True(t, ok)
+	require.Contains(t, out, "\n			Index: "+
+		"int64(1),\n			}")
+	require.NotContains(t, out, "\n\t\t\t\tIndex:")
+
+	for _, line := range strings.Split(out, "\n") {
+		require.LessOrEqual(t, visualLen(line), columnLimit)
+	}
+}

formatter/func_sig_formatter.go

@@ -311,6 +311,9 @@ func FormatFuncSignatureNext(signature, indent string, colLimit,
 	formatted = collapseMultilineParenReturnListIfFits(
 		formatted, colLimit, tabStop,
 	)
+	formatted = breakLongTypeArgListsIfNeeded(
+		formatted, colLimit, tabStop,
+	)
 	needsBlank := hasNewlineOutsideBraces(formatted)
 
 	return formatted, needsBlank
@@ -405,6 +408,136 @@ func collapseMultilineParenReturnListIfFits(signature string, colLimit,
 	return signature
 }
 
+func breakLongTypeArgListsIfNeeded(signature string, colLimit,
+	tabStop int) string {
+
+	for {
+		lines := strings.Split(signature, "\n")
+		changed := false
+
+		for i, line := range lines {
+			if width.VisualLenWithTab(line, tabStop) <= colLimit {
+				continue
+			}
+
+			indent := leadingWhitespace(line)
+			rewritten, ok := breakFirstTypeArgListInLine(
+				line, indent,
+			)
+			if !ok {
+				continue
+			}
+
+			newLines := append([]string{}, lines[:i]...)
+			newLines = append(
+				newLines, strings.Split(rewritten, "\n")...,
+			)
+			newLines = append(newLines, lines[i+1:]...)
+
+			signature = strings.Join(newLines, "\n")
+			changed = true
+			break
+		}
+
+		if !changed {
+			return signature
+		}
+	}
+}
+
+func breakFirstTypeArgListInLine(line, indent string) (string, bool) {
+	b := []byte(line)
+
+	for i := 0; i < len(b); {
+		switch {
+		case scanner.IsStringStart(b, i):
+			i = scanner.ScanString(b, i)
+
+		case scanner.IsLineCommentStart(b, i):
+			return line, false
+
+		case scanner.IsBlockCommentStart(b, i):
+			i = scanner.ScanBlockComment(b, i)
+
+		case b[i] == '[':
+			if !isTypeArgListStart(line, i) {
+				i++
+				continue
+			}
+			end := scanner.ScanBalanced(b, i, '[', ']')
+			if end == -1 {
+				return line, false
+			}
+
+			content := strings.TrimSpace(line[i+1 : end])
+			parts := filterNonEmptyTrimmed(
+				scanner.SplitTopLevelAny(content),
+			)
+			if len(parts) <= 1 {
+				i++
+				continue
+			}
+
+			var out strings.Builder
+			out.Grow(len(line) + len(parts)*4)
+			out.WriteString(line[:i+1])
+			out.WriteByte('\n')
+			contIndent := indent + "\t"
+			for _, part := range parts {
+				out.WriteString(contIndent)
+				out.WriteString(strings.TrimSpace(part))
+				out.WriteString(",\n")
+			}
+			out.WriteString(indent)
+			out.WriteByte(']')
+			out.WriteString(line[end+1:])
+
+			return out.String(), true
+
+		default:
+			i++
+		}
+	}
+
+	return line, false
+}
+
+func isTypeArgListStart(line string, idx int) bool {
+	if idx <= 0 || idx >= len(line) || line[idx] != '[' {
+		return false
+	}
+
+	j := idx - 1
+	for j >= 0 && (line[j] == ' ' || line[j] == '\t') {
+		j--
+	}
+	if j < 0 {
+		return false
+	}
+	if line[j] == ']' {
+		return true
+	}
+	if line[j] == '.' {
+		k := j - 1
+		for k >= 0 && isIdentChar(line[k]) {
+			k--
+		}
+
+		return k != j-1
+	}
+	if !isIdentChar(line[j]) {
+		return false
+	}
+
+	k := j
+	for k >= 0 && isIdentChar(line[k]) {
+		k--
+	}
+	ident := line[k+1 : j+1]
+
+	return ident != "map"
+}
+
 func isFuncLitSignature(signature string) bool {
 	trimmed := strings.TrimSpace(signature)
 	// Signatures passed to the formatter may include non-whitespace
@@ -1558,7 +1691,7 @@ func (f *FuncSigFormatter) findMatchingParen(s string, start int) int {
 // splitParams splits parameter list by commas, respecting nested
 // parens/brackets.
 func (f *FuncSigFormatter) splitParams(params string) []string {
-	return scanner.SplitTopLevel(params)
+	return scanner.SplitTopLevelAny(params)
 }
 
 func (f *FuncSigFormatter) splitFuncParamList(params string) []string {

formatter/func_sig_formatter_generics_test.go

@@ -0,0 +1,96 @@
+package formatter
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+
+	"github.com/bhandras/llformat/width"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFormatFuncSigs_GenericReturnListDoesNotOverflow(t *testing.T) {
+	const src = `package p
+
+type RecvXXXXXX[T1, T2 any] struct{}
+type RetXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2 any] interface{}
+type P interface{}
+
+func (s *RecvXXXXXX[T1, T2]) Select(p P) (RetXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2], error) {
+	return nil, nil
+}
+`
+
+	out, changed := FormatFuncSigsInSource([]byte(src), 80, 8)
+	if !changed {
+		out = []byte(src)
+	}
+
+	for _, line := range strings.Split(string(out), "\n") {
+		if line == "" {
+			continue
+		}
+		require.LessOrEqual(
+			t, width.VisualLenWithTab(line, 8), 80, "line "+
+				"exceeds configured column limit: %q", line,
+		)
+	}
+}
+
+func TestBreakLongTypeArgListsIfNeeded_BreaksReceiver(t *testing.T) {
+	const sig = "func (r *ReceiverXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, " +
+		"T3]) VeryLongMethodNameForSig() " +
+		"ReturnXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, T3] {"
+
+	out := breakLongTypeArgListsIfNeeded(sig, 80, 8)
+
+	require.Contains(
+		t, out, "ReceiverXXXXXXXXXXXXXXXXXXXXXXXXXXXX["+
+			"\n	T1,\n	T2,\n	T3,\n]",
+	)
+}
+
+func TestFormatFuncSignatureNext_BreaksGenericTypeArgs(t *testing.T) {
+	const sig = "func (r *ReceiverXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, " +
+		"T3]) VeryLongMethodNameForSig() " +
+		"ReturnXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, T3] {"
+
+	out, _ := FormatFuncSignatureNext(sig, "", 80, 8)
+
+	require.Contains(
+		t, out, "ReceiverXXXXXXXXXXXXXXXXXXXXXXXXXXXX["+
+			"\n	T1,\n	T2,\n	T3,\n]",
+	)
+}
+
+func TestFormatFuncSignatureNext_WithASTSignature(t *testing.T) {
+	const src = `package p
+
+type ReceiverXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, T3 any] struct{}
+type ReturnXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, T3 any] struct{}
+
+func (r *ReceiverXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, T3]) VeryLongMethodNameForSig() ReturnXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, T3] {
+	return ReturnXXXXXXXXXXXXXXXXXXXXXXXXXXXX[T1, T2, T3]{}
+}
+`
+
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "in.go", src, parser.AllErrors)
+	require.NoError(t, err)
+	require.NotEmpty(t, file.Decls)
+
+	decl, ok := file.Decls[len(file.Decls)-1].(*ast.FuncDecl)
+	require.True(t, ok)
+	funcStart := fset.Position(decl.Pos()).Offset
+	bracePos := fset.Position(decl.Body.Lbrace).Offset
+
+	signature := strings.TrimSpace(src[funcStart : bracePos+1])
+	out, _ := FormatFuncSignatureNext(signature, "", 80, 8)
+
+	require.Contains(
+		t, out, "ReceiverXXXXXXXXXXXXXXXXXXXXXXXXXXXX["+
+			"\n	T1,\n	T2,\n	T3,\n]",
+	)
+}

formatter/pipeline_property_matrix_test.go

@@ -223,7 +223,8 @@ func f() {
 							// AST-based printing.
 							if snippetIndex == 6 {
 								require.Contains(
-									t, string(
+									t,
+									string(
 										out1,
 									), "k"+
 										"eep me",