codegen: make union collection traversal deterministic (#3904)

Sort object attributes before collecting union types in service and HTTP codegen so NameScope-assigned union identifiers do not oscillate across runs. Add regression tests that assert union naming remains stable when object field declaration order is reversed.

Author: raphael

codegen/service/service_data.go

@@ -1073,7 +1073,7 @@ func collectUnionTypes(att *expr.AttributeExpr, scope *codegen.NameScope, loc *c
 		seen[dt.ID()] = struct{}{}
 		collectUnionTypes(dt.Attribute(), scope, codegen.UserTypeLocation(dt), unions, seen)
 	case *expr.Object:
-		for _, nat := range *dt {
+		for _, nat := range sortedNamedAttributes(*dt) {
 			collectUnionTypes(nat.Attribute, scope, loc, unions, seen)
 		}
 	case *expr.Array:
@@ -1152,7 +1152,7 @@ func collectViewUnionTypes(att *expr.AttributeExpr, scope *codegen.NameScope, lo
 		seen[dt.ID()] = struct{}{}
 		collectViewUnionTypes(dt.Attribute(), scope, loc, unions, seen)
 	case *expr.Object:
-		for _, nat := range *dt {
+		for _, nat := range sortedNamedAttributes(*dt) {
 			collectViewUnionTypes(nat.Attribute, scope, loc, unions, seen)
 		}
 	case *expr.Array:
@@ -1208,6 +1208,21 @@ func buildViewUnionTypeData(u *expr.Union, scope *codegen.NameScope, loc *codege
 	}
 }
 
+// sortedNamedAttributes returns object fields sorted by attribute name.
+// Union naming uses NameScope uniqueness, so callers that discover unions while
+// traversing objects must use a deterministic field order to avoid oscillating
+// generated identifiers across runs.
+func sortedNamedAttributes(attrs []*expr.NamedAttributeExpr) []*expr.NamedAttributeExpr {
+	if len(attrs) < 2 {
+		return attrs
+	}
+	sorted := slices.Clone(attrs)
+	sort.Slice(sorted, func(i, j int) bool {
+		return sorted[i].Name < sorted[j].Name
+	})
+	return sorted
+}
+
 // primitiveAliasGoType resolves the native Go type for a primitive alias branch.
 // It uses expr.IsPrimitive to enforce the type contract and then unwraps aliases.
 func primitiveAliasGoType(dt expr.DataType) (string, bool) {

codegen/service/service_data_union_order_test.go

@@ -0,0 +1,92 @@
+package service
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"goa.design/goa/v3/codegen"
+	"goa.design/goa/v3/expr"
+)
+
+func TestCollectUnionTypesDeterministicAcrossObjectOrder(t *testing.T) {
+	sourceFromSignals := makeUnionForOrderTest("source",
+		"physical_point",
+		"synthetic_series",
+	)
+	sourceFromInputs := makeUnionForOrderTest("source",
+		"time_series",
+		"energy_rates",
+	)
+
+	forward := &expr.AttributeExpr{
+		Type: &expr.Object{
+			{
+				Name: "alpha",
+				Attribute: &expr.AttributeExpr{
+					Type: sourceFromSignals,
+				},
+			},
+			{
+				Name: "beta",
+				Attribute: &expr.AttributeExpr{
+					Type: sourceFromInputs,
+				},
+			},
+		},
+	}
+	reverse := &expr.AttributeExpr{
+		Type: &expr.Object{
+			{
+				Name: "beta",
+				Attribute: &expr.AttributeExpr{
+					Type: sourceFromInputs,
+				},
+			},
+			{
+				Name: "alpha",
+				Attribute: &expr.AttributeExpr{
+					Type: sourceFromSignals,
+				},
+			},
+		},
+	}
+
+	loc := &codegen.Location{
+		RelImportPath: "gen/service",
+	}
+	forwardNames := collectServiceUnionTypeNames(forward, loc)
+	reverseNames := collectServiceUnionTypeNames(reverse, loc)
+
+	require.Len(t, forwardNames, 2)
+	require.Equal(t, forwardNames, reverseNames)
+}
+
+func collectServiceUnionTypeNames(att *expr.AttributeExpr, loc *codegen.Location) map[string]string {
+	scope := codegen.NewNameScope()
+	seen := make(map[string]struct{})
+	unionByHash := make(map[string]*UnionTypeData)
+	collectUnionTypes(att, scope, loc, unionByHash, seen)
+
+	names := make(map[string]string, len(unionByHash))
+	for hash, data := range unionByHash {
+		names[hash] = data.Name
+	}
+	return names
+}
+
+func makeUnionForOrderTest(typeName string, variants ...string) *expr.Union {
+	values := make([]*expr.NamedAttributeExpr, len(variants))
+	for i, variant := range variants {
+		values[i] = &expr.NamedAttributeExpr{
+			Name: variant,
+			Attribute: &expr.AttributeExpr{
+				Type: expr.String,
+			},
+		}
+	}
+	return &expr.Union{
+		TypeName: typeName,
+		Values:   values,
+	}
+}

http/codegen/service_data.go

@@ -2722,7 +2722,7 @@ func collectHTTPUnionTypes(att *expr.AttributeExpr, scope *codegen.NameScope, un
 		seen[dt.ID()] = struct{}{}
 		collectHTTPUnionTypes(dt.Attribute(), scope, unions, seen)
 	case *expr.Object:
-		for _, nat := range *dt {
+		for _, nat := range sortedNamedAttributes(*dt) {
 			collectHTTPUnionTypes(nat.Attribute, scope, unions, seen)
 		}
 	case *expr.Array:
@@ -2769,6 +2769,21 @@ func buildHTTPUnionTypeData(u *expr.Union, scope *codegen.NameScope) *service.Un
 	}
 }
 
+// sortedNamedAttributes returns object fields sorted by attribute name.
+// Union naming uses NameScope uniqueness, so callers that discover unions while
+// traversing objects must use a deterministic field order to avoid oscillating
+// generated identifiers across runs.
+func sortedNamedAttributes(attrs []*expr.NamedAttributeExpr) []*expr.NamedAttributeExpr {
+	if len(attrs) < 2 {
+		return attrs
+	}
+	sorted := slices.Clone(attrs)
+	sort.Slice(sorted, func(i, j int) bool {
+		return sorted[i].Name < sorted[j].Name
+	})
+	return sorted
+}
+
 func (sds *ServicesData) attributeTypeData(ut expr.UserType, req, ptr, server bool, rd *ServiceData) *TypeData {
 	if ut == expr.Empty {
 		return nil

http/codegen/service_data_union_order_test.go

@@ -0,0 +1,90 @@
+package codegen
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	cg "goa.design/goa/v3/codegen"
+	svc "goa.design/goa/v3/codegen/service"
+	"goa.design/goa/v3/expr"
+)
+
+func TestCollectHTTPUnionTypesDeterministicAcrossObjectOrder(t *testing.T) {
+	sourceFromSignals := makeUnionForOrderTest("source",
+		"physical_point",
+		"synthetic_series",
+	)
+	sourceFromInputs := makeUnionForOrderTest("source",
+		"time_series",
+		"energy_rates",
+	)
+
+	forward := &expr.AttributeExpr{
+		Type: &expr.Object{
+			{
+				Name: "alpha",
+				Attribute: &expr.AttributeExpr{
+					Type: sourceFromSignals,
+				},
+			},
+			{
+				Name: "beta",
+				Attribute: &expr.AttributeExpr{
+					Type: sourceFromInputs,
+				},
+			},
+		},
+	}
+	reverse := &expr.AttributeExpr{
+		Type: &expr.Object{
+			{
+				Name: "beta",
+				Attribute: &expr.AttributeExpr{
+					Type: sourceFromInputs,
+				},
+			},
+			{
+				Name: "alpha",
+				Attribute: &expr.AttributeExpr{
+					Type: sourceFromSignals,
+				},
+			},
+		},
+	}
+
+	forwardNames := collectHTTPUnionTypeNames(forward)
+	reverseNames := collectHTTPUnionTypeNames(reverse)
+
+	require.Len(t, forwardNames, 2)
+	require.Equal(t, forwardNames, reverseNames)
+}
+
+func collectHTTPUnionTypeNames(att *expr.AttributeExpr) map[string]string {
+	scope := cg.NewNameScope()
+	seen := make(map[string]struct{})
+	unionByHash := make(map[string]*svc.UnionTypeData)
+	collectHTTPUnionTypes(att, scope, unionByHash, seen)
+
+	names := make(map[string]string, len(unionByHash))
+	for hash, data := range unionByHash {
+		names[hash] = data.Name
+	}
+	return names
+}
+
+func makeUnionForOrderTest(typeName string, variants ...string) *expr.Union {
+	values := make([]*expr.NamedAttributeExpr, len(variants))
+	for i, variant := range variants {
+		values[i] = &expr.NamedAttributeExpr{
+			Name: variant,
+			Attribute: &expr.AttributeExpr{
+				Type: expr.String,
+			},
+		}
+	}
+	return &expr.Union{
+		TypeName: typeName,
+		Values:   values,
+	}
+}