Fix line splitting for statements with init clauses and nested struct…

_fixtures/chained_args.go

@@ -0,0 +1,22 @@
+package fixtures
+
+import "strings"
+
+type Logger struct{}
+
+func (l Logger) Str(k, v string) Logger { return l }
+func (l Logger) Msgf(format string, args ...interface{}) {}
+
+func Map[T, U any](collection []T, fn func(T, int) U) []U {
+	return nil
+}
+
+func testChainedArgs() {
+	messages := []string{}
+	l := Logger{}
+
+	// Long argument inside a chained method call - should split the arguments
+	l.Str("key", strings.Join(Map(messages, func(message string, _ int) string { return message + message + message }), ",")).
+		Msgf("Message with format %s", "arg")
+}
+

_fixtures/chained_args__exp.go

@@ -0,0 +1,21 @@
+package fixtures
+
+import "strings"
+
+type Logger struct{}
+
+func (l Logger) Str(k, v string) Logger                  { return l }
+func (l Logger) Msgf(format string, args ...interface{}) {}
+
+func Map[T, U any](collection []T, fn func(T, int) U) []U {
+	return nil
+}
+
+func testChainedArgs() {
+	messages := []string{}
+	l := Logger{}
+
+	// Long argument inside a chained method call - should split the arguments
+	l.Str("key", strings.Join(Map(messages, func(message string, _ int) string { return message + message + message }), ",")).
+		Msgf("Message with format %s", "arg")
+}

_fixtures/chained_calls__exp.go

@@ -20,9 +20,16 @@ func ChainedCalls() {
 	NewChain().ChainCall(
 		"a really really really really really long argument4",
 		"another really really really really really long argument4",
-		fmt.Sprintf("%v", "this is a long method"),
+		fmt.Sprintf(
+			"%v",
+			"this is a long method",
+		),
 	).
-		ChainCall("a really really really really really long argument5", "another really really really really really long argument5", "a third really really really really really long argument5").
+		ChainCall(
+			"a really really really really really long argument5",
+			"another really really really really really long argument5",
+			"a third really really really really really long argument5",
+		).
 		ChainCall("a", "b", fmt.Sprintf("%v", "this is a long method"))
 	NewChain().ChainCall("a", "b", "c").ChainCall("d", "e", "f")
 	NewChain().ChainCall("a", "b", "c").

_fixtures/composite_lit.go

@@ -0,0 +1,24 @@
+package fixtures
+
+type Request struct {
+	Entity       string
+	Fields       []string
+	VersionCheck bool
+}
+
+func update(ctx string, req Request) error {
+	return nil
+}
+
+func testCompositeLit() {
+	// Struct literal with long field line that should be split
+	update(
+		"ctx",
+		Request{
+			Entity: "enrollment", Fields: []string{"field1", "field2", "field3", "field4"}, VersionCheck: true,
+		},
+	)
+
+	// Struct literal with nested long slice
+	update("ctx", Request{Entity: "test", Fields: []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}, VersionCheck: false})
+}

_fixtures/composite_lit__exp.go

@@ -0,0 +1,33 @@
+package fixtures
+
+type Request struct {
+	Entity       string
+	Fields       []string
+	VersionCheck bool
+}
+
+func update(ctx string, req Request) error {
+	return nil
+}
+
+func testCompositeLit() {
+	// Struct literal with long field line that should be split
+	update(
+		"ctx",
+		Request{
+			Entity:       "enrollment",
+			Fields:       []string{"field1", "field2", "field3", "field4"},
+			VersionCheck: true,
+		},
+	)
+
+	// Struct literal with nested long slice
+	update(
+		"ctx",
+		Request{
+			Entity:       "test",
+			Fields:       []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"},
+			VersionCheck: false,
+		},
+	)
+}

_fixtures/for_init.go

@@ -0,0 +1,18 @@
+package fixtures
+
+func getValue(a, b, c, d, e string) int {
+	return 0
+}
+
+func testForInit() {
+	// For statement with long init clause
+	for i := getValue("argument1", "argument2", "argument3", "argument4", "argument5"); i < 10; i++ {
+		println(i)
+	}
+
+	// For with long condition
+	for j := 0; j < getValue("value1", "value2", "value3", "value4", "value5"); j++ {
+		println(j)
+	}
+}
+

_fixtures/for_init__exp.go

@@ -0,0 +1,23 @@
+package fixtures
+
+func getValue(a, b, c, d, e string) int {
+	return 0
+}
+
+func testForInit() {
+	// For statement with long init clause
+	for i := getValue(
+		"argument1",
+		"argument2",
+		"argument3",
+		"argument4",
+		"argument5",
+	); i < 10; i++ {
+		println(i)
+	}
+
+	// For with long condition
+	for j := 0; j < getValue("value1", "value2", "value3", "value4", "value5"); j++ {
+		println(j)
+	}
+}

_fixtures/func_lit_body.go

@@ -0,0 +1,24 @@
+package fixtures
+
+type LongTypeName struct {
+	Value int
+}
+
+func (l LongTypeName) Compare(other LongTypeName) int {
+	return l.Value - other.Value
+}
+
+func SortFunc[T any](collection []T, fn func(T, T) int) {}
+
+func testFuncLitBody() {
+	// Function literal with long body that should be expanded
+	items := []LongTypeName{}
+	SortFunc(
+		items,
+		func(a, b LongTypeName) int { return a.Compare(b) + a.Compare(b) + a.Compare(b) + a.Compare(b) },
+	)
+
+	// Single line function literal that fits - should stay as is
+	SortFunc(items, func(a, b LongTypeName) int { return a.Compare(b) })
+}
+

_fixtures/func_lit_body__exp.go

@@ -0,0 +1,25 @@
+package fixtures
+
+type LongTypeName struct {
+	Value int
+}
+
+func (l LongTypeName) Compare(other LongTypeName) int {
+	return l.Value - other.Value
+}
+
+func SortFunc[T any](collection []T, fn func(T, T) int) {}
+
+func testFuncLitBody() {
+	// Function literal with long body that should be expanded
+	items := []LongTypeName{}
+	SortFunc(
+		items,
+		func(a, b LongTypeName) int {
+			return a.Compare(b) + a.Compare(b) + a.Compare(b) + a.Compare(b)
+		},
+	)
+
+	// Single line function literal that fits - should stay as is
+	SortFunc(items, func(a, b LongTypeName) int { return a.Compare(b) })
+}

_fixtures/if_init.go

@@ -0,0 +1,20 @@
+package fixtures
+
+func doSomething(a, b, c, d, e string) error {
+	return nil
+}
+
+func testIfInit() {
+	// If statement with long init clause
+	if err := doSomething("argument1", "argument2", "argument3", "argument4", "argument5"); err != nil {
+		println(err)
+	}
+
+	// Nested if with long init
+	if x := doSomething("value1", "value2", "value3", "value4", "value5"); x == nil {
+		if y := doSomething("nested1", "nested2", "nested3", "nested4", "nested5"); y == nil {
+			println("both nil")
+		}
+	}
+}
+

_fixtures/if_init__exp.go

@@ -0,0 +1,25 @@
+package fixtures
+
+func doSomething(a, b, c, d, e string) error {
+	return nil
+}
+
+func testIfInit() {
+	// If statement with long init clause
+	if err := doSomething(
+		"argument1",
+		"argument2",
+		"argument3",
+		"argument4",
+		"argument5",
+	); err != nil {
+		println(err)
+	}
+
+	// Nested if with long init
+	if x := doSomething("value1", "value2", "value3", "value4", "value5"); x == nil {
+		if y := doSomething("nested1", "nested2", "nested3", "nested4", "nested5"); y == nil {
+			println("both nil")
+		}
+	}
+}

_fixtures/switch_init.go

@@ -0,0 +1,18 @@
+package fixtures
+
+func getType(a, b, c, d, e, f string) int {
+	return 0
+}
+
+func testSwitchInit() {
+	// Switch statement with long init clause
+	switch v := getType("argument1", "argument2", "argument3", "argument4", "argument5", "argument6"); v {
+	case 1:
+		println("one")
+	case 2:
+		println("two")
+	default:
+		println("other")
+	}
+}
+

_fixtures/switch_init__exp.go

@@ -0,0 +1,24 @@
+package fixtures
+
+func getType(a, b, c, d, e, f string) int {
+	return 0
+}
+
+func testSwitchInit() {
+	// Switch statement with long init clause
+	switch v := getType(
+		"argument1",
+		"argument2",
+		"argument3",
+		"argument4",
+		"argument5",
+		"argument6",
+	); v {
+	case 1:
+		println("one")
+	case 2:
+		println("two")
+	default:
+		println("other")
+	}
+}

annotation.go

@@ -79,6 +79,12 @@ func HasAnnotationRecursive(node dst.Node) bool {
 				return true
 			}
 		}
+	case *dst.CompositeLit:
+		for _, elt := range n.Elts {
+			if HasAnnotation(elt) {
+				return true
+			}
+		}
 	}
 
 	return false