fix: properly expand value to key-value fields in slices or maps of structs

Signed-off-by: Ilya Lesikov <ilya@lesikov.com>

Author: ilya-lesikov

pkg/formatter/structs.go

@@ -278,31 +278,78 @@ func convertPositionalToKeyed(f *dst.File, structDefs map[string][]string) {
 			return true
 		}
 
-		if !isPositionalLiteral(cl) {
-			return true
-		}
+		// Process this literal and all nested children
+		processCompositeLit(cl, nil, structDefs)
 
-		// Handle anonymous struct type
-		if st, ok := cl.Type.(*dst.StructType); ok {
-			fieldNames := getFieldNamesFromStructType(st)
-			convertToKeyedLiteral(cl, fieldNames)
-			return true
-		}
+		// Don't let dst.Inspect descend into children - we handle them
+		return false
+	})
+}
 
-		// Handle named struct type
-		typeName := extractTypeName(cl.Type)
-		if typeName == "" {
-			return true
+func processCompositeLit(cl *dst.CompositeLit, inheritedFieldNames []string, structDefs map[string][]string) {
+	// Determine field names for THIS literal
+	fieldNames := resolveFieldNames(cl.Type, inheritedFieldNames, structDefs)
+
+	// Convert if positional and we know the field names
+	if len(fieldNames) > 0 && isPositionalLiteral(cl) {
+		convertToKeyedLiteral(cl, fieldNames)
+	}
+
+	// Determine field names to pass to children (from element type)
+	childFieldNames := getElementFieldNames(cl.Type, structDefs)
+
+	// Process all child elements
+	for _, elt := range cl.Elts {
+		processElement(elt, childFieldNames, structDefs)
+	}
+}
+
+func processElement(elt dst.Expr, inheritedFieldNames []string, structDefs map[string][]string) {
+	switch e := elt.(type) {
+	case *dst.CompositeLit:
+		processCompositeLit(e, inheritedFieldNames, structDefs)
+	case *dst.KeyValueExpr:
+		// Value might be a composite literal (map values, struct fields)
+		if child, ok := e.Value.(*dst.CompositeLit); ok {
+			processCompositeLit(child, inheritedFieldNames, structDefs)
 		}
+	}
+}
 
-		fieldNames, exists := structDefs[typeName]
-		if !exists {
-			// Type not in this file - leave untouched
-			return true
+func resolveFieldNames(t dst.Expr, inherited []string, structDefs map[string][]string) []string {
+	if t == nil {
+		return inherited
+	}
+
+	// Anonymous struct type
+	if st, ok := t.(*dst.StructType); ok {
+		return getFieldNamesFromStructType(st)
+	}
+
+	// Named type
+	if typeName := extractTypeName(t); typeName != "" {
+		if names, exists := structDefs[typeName]; exists {
+			return names
 		}
+	}
 
-		convertToKeyedLiteral(cl, fieldNames)
+	return nil
+}
 
-		return true
-	})
+func getElementFieldNames(t dst.Expr, structDefs map[string][]string) []string {
+	if t == nil {
+		return nil
+	}
+
+	// Slice/array: []T or [N]T
+	if at, ok := t.(*dst.ArrayType); ok {
+		return resolveFieldNames(at.Elt, nil, structDefs)
+	}
+
+	// Map: map[K]V - return value type's field names
+	if mt, ok := t.(*dst.MapType); ok {
+		return resolveFieldNames(mt.Value, nil, structDefs)
+	}
+
+	return nil
 }

pkg/formatter/testdata/expected.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strings"
 )
 
@@ -47,11 +48,18 @@ var (
 	DefaultStatus StatusCode = "default"
 	ErrorStatus   StatusCode = "error"
 
-	globalA      = 5
-	globalB      = 3
-	globalMiddle = 7
-	globalZ      = 10
-	singleConst  = 1
+	globalA        = 5
+	globalB        = 3
+	globalMiddle   = 7
+	globalZ        = 10
+	singleConst    = 1
+	sliceOfStructs = []struct {
+		content string
+		path    string
+	}{
+		{path: filepath.Join("a", "b"), content: "content1"},
+		{path: filepath.Join("c", "d"), content: "content2"},
+	}
 )
 
 // Test: type declared in wrong place

pkg/formatter/testdata/input.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strings"
 )
 
@@ -341,6 +342,15 @@ func createEmpty() *PositionalTest {
 	return &PositionalTest{}
 }
 
+// Test: slice of anonymous structs with positional literals
+var sliceOfStructs = []struct {
+	path    string
+	content string
+}{
+	{filepath.Join("a", "b"), "content1"},
+	{filepath.Join("c", "d"), "content2"},
+}
+
 // Test: multi-line func signature should collapse to single line
 func multiLineFunc(
 	a int,