experimental: merge allOf member extensions before type generation (#22)

Refactor allOf type generation to merge extensions from all allOf members
into a composite before deciding what code to generate, mirroring V2's
MergeSchemas approach. This was surfaced by the issue 1957 test, which
uses the standard OpenAPI 3.0 pattern of combining a $ref with
extension-only allOf members:

    id:
      allOf:
        - $ref: '#/components/schemas/ID'        # has x-go-type
        - x-go-type-skip-optional-pointer: true   # extension-only

Previously, V3 preserved the allOf structure as-is, so
generateAllOfType() only collected struct fields from each member. When a
$ref target was a type-override alias (no struct properties), there were
no fields to collect, producing an empty struct. Extensions on allOf
members were also never propagated to the parent field.

The fix adds three pieces:

- mergeExtensions(dst, src) in extension.go: field-by-field merge helper
  for the Extensions struct (later values win).

- mergeAllOfExtensions() + hasAnyFields() in codegen.go: iterates allOf
  member descriptors, resolves $ref targets from the schema index, and
  merges all extensions. generateAllOfType() now calls this at the top
  and, when the composite has no struct fields but carries a TypeOverride,
  emits a type alias instead of an empty struct.

- GenerateStructFields() in typegen.go: when a property is itself an
  allOf, merges extensions from its allOf members into the property's
  extensions, so x-go-type-skip-optional-pointer propagates to the
  field declaration in the parent struct.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: mromaszewicz

experimental/codegen/internal/codegen.go

@@ -641,6 +641,7 @@ type allOfMemberInfo struct {
 	unionType string        // non-empty if this member is a oneOf/anyOf union
 	unionDesc *SchemaDescriptor
 	required  []string // required fields from this allOf member
+	refType   string   // non-empty if this member is a $ref (the JSON pointer)
 }
 
 // generateAllOfType generates a struct with flattened properties from all allOf members.
@@ -652,6 +653,10 @@ func generateAllOfType(gen *TypeGenerator, desc *SchemaDescriptor) string {
 		return ""
 	}
 
+	// Merge extensions from all allOf members into a composite.
+	// This mirrors V2's MergeSchemas which merges extensions before type generation.
+	mergedExt := mergeAllOfExtensions(desc, gen.schemaIndex)
+
 	// Merge all fields, checking for conflicts
 	mergedFields := make(map[string]StructField) // keyed by JSONName
 	var fieldOrder []string                       // preserve order
@@ -687,6 +692,7 @@ func generateAllOfType(gen *TypeGenerator, desc *SchemaDescriptor) string {
 		} else if proxy.IsReference() {
 			// Reference to another schema - get its fields
 			ref := proxy.GetReference()
+			info.refType = ref
 			if target, ok := gen.schemaIndex[ref]; ok {
 				info.fields = gen.collectFieldsRecursive(target)
 			}
@@ -703,6 +709,15 @@ func generateAllOfType(gen *TypeGenerator, desc *SchemaDescriptor) string {
 		members = append(members, info)
 	}
 
+	// After field collection: if no fields were found, check if the composite
+	// should be a type alias (TypeOverride from a $ref target, no struct properties).
+	if len(mergedFields) == 0 && !hasAnyFields(members) {
+		if mergedExt != nil && mergedExt.TypeOverride != nil {
+			desc.Extensions = mergedExt
+			return generateTypeOverrideAlias(gen, desc)
+		}
+	}
+
 	// Merge fields from allOf members
 	for _, member := range members {
 		if member.unionType != "" {
@@ -778,6 +793,67 @@ func generateAllOfType(gen *TypeGenerator, desc *SchemaDescriptor) string {
 	return code
 }
 
+// mergeAllOfExtensions merges extensions from all allOf member descriptors into a
+// single composite. For $ref members, the target schema's extensions are merged first,
+// then the allOf member descriptor's own extensions (so inline overrides win).
+func mergeAllOfExtensions(desc *SchemaDescriptor, schemaIndex map[string]*SchemaDescriptor) *Extensions {
+	if desc == nil || len(desc.AllOf) == 0 {
+		return nil
+	}
+
+	merged := &Extensions{}
+	hasAny := false
+
+	for i, memberDesc := range desc.AllOf {
+		if memberDesc == nil {
+			continue
+		}
+
+		// For $ref members, merge the target schema's extensions
+		if memberDesc.IsReference() {
+			if target, ok := schemaIndex[memberDesc.Ref]; ok && target.Extensions != nil {
+				mergeExtensions(merged, target.Extensions)
+				hasAny = true
+			}
+		}
+
+		// Merge the member descriptor's own extensions (inline extensions override $ref target)
+		if memberDesc.Extensions != nil {
+			mergeExtensions(merged, memberDesc.Extensions)
+			hasAny = true
+		}
+
+		// Also check if the allOf proxy in the schema has extensions that were parsed
+		// on the descriptor at this index
+		if desc.Schema != nil && i < len(desc.Schema.AllOf) {
+			proxy := desc.Schema.AllOf[i]
+			memberSchema := proxy.Schema()
+			if memberSchema != nil && memberSchema.Extensions != nil {
+				ext, err := ParseExtensions(memberSchema.Extensions, desc.Path.Append("allOf", fmt.Sprintf("%d", i)).String())
+				if err == nil && ext != nil {
+					mergeExtensions(merged, ext)
+					hasAny = true
+				}
+			}
+		}
+	}
+
+	if !hasAny {
+		return nil
+	}
+	return merged
+}
+
+// hasAnyFields returns true if any allOf member contributed struct fields or union types.
+func hasAnyFields(members []allOfMemberInfo) bool {
+	for _, m := range members {
+		if len(m.fields) > 0 || m.unionType != "" {
+			return true
+		}
+	}
+	return false
+}
+
 // generateAllOfStructWithUnions generates an allOf struct that contains union fields.
 func generateAllOfStructWithUnions(name string, fields []StructField, unionFields []StructField, doc string, tagGen *StructTagGenerator) string {
 	b := NewCodeBuilder()

experimental/codegen/internal/extension.go

@@ -277,6 +277,44 @@ func buildLegacyTypeOverride(typeName string, importVal any) *TypeOverride {
 	return override
 }
 
+// mergeExtensions copies non-zero/non-nil fields from src into dst.
+// Later values win (src overrides dst where set).
+func mergeExtensions(dst, src *Extensions) {
+	if src == nil || dst == nil {
+		return
+	}
+	if src.TypeOverride != nil {
+		dst.TypeOverride = src.TypeOverride
+	}
+	if src.NameOverride != "" {
+		dst.NameOverride = src.NameOverride
+	}
+	if src.TypeNameOverride != "" {
+		dst.TypeNameOverride = src.TypeNameOverride
+	}
+	if src.SkipOptionalPointer != nil {
+		dst.SkipOptionalPointer = src.SkipOptionalPointer
+	}
+	if src.JSONIgnore != nil {
+		dst.JSONIgnore = src.JSONIgnore
+	}
+	if src.OmitEmpty != nil {
+		dst.OmitEmpty = src.OmitEmpty
+	}
+	if src.OmitZero != nil {
+		dst.OmitZero = src.OmitZero
+	}
+	if len(src.EnumVarNames) > 0 {
+		dst.EnumVarNames = src.EnumVarNames
+	}
+	if src.DeprecatedReason != "" {
+		dst.DeprecatedReason = src.DeprecatedReason
+	}
+	if src.Order != nil {
+		dst.Order = src.Order
+	}
+}
+
 // Type conversion helpers that include the extension name in error messages
 
 func asString(val any, extName string) (string, error) {

experimental/codegen/internal/test/previous_version/issues/issue_1957/output/types.gen.go

@@ -52,22 +52,25 @@ func TestTypeWithOptionalFieldJSONRoundTrip(t *testing.T) {
 	}
 }
 
-// TestTypeWithAllOfInstantiation verifies TypeWithAllOf with its nested ID field.
+// TestTypeWithAllOfInstantiation verifies TypeWithAllOf with its ID field.
+// After the allOf extension merge fix, ID should be googleuuid.UUID (value type, non-pointer)
+// because x-go-type-skip-optional-pointer is merged from the allOf member.
 func TestTypeWithAllOfInstantiation(t *testing.T) {
-	idField := &TypeWithAllOfID{}
+	id := uuid.MustParse("550e8400-e29b-41d4-a716-446655440000")
 	tw := TypeWithAllOf{
-		ID: idField,
+		ID: id,
 	}
 
-	if tw.ID == nil {
-		t.Fatal("ID should not be nil")
+	if tw.ID != id {
+		t.Errorf("ID = %v, want %v", tw.ID, id)
 	}
 }
 
 // TestTypeWithAllOfJSONRoundTrip verifies JSON round-trip for TypeWithAllOf.
 func TestTypeWithAllOfJSONRoundTrip(t *testing.T) {
+	id := uuid.MustParse("550e8400-e29b-41d4-a716-446655440000")
 	original := TypeWithAllOf{
-		ID: &TypeWithAllOfID{},
+		ID: id,
 	}
 
 	data, err := json.Marshal(original)
@@ -80,8 +83,8 @@ func TestTypeWithAllOfJSONRoundTrip(t *testing.T) {
 		t.Fatalf("Unmarshal failed: %v", err)
 	}
 
-	if decoded.ID == nil {
-		t.Fatal("ID should not be nil after round trip")
+	if decoded.ID != id {
+		t.Errorf("ID = %v, want %v", decoded.ID, id)
 	}
 }
 
@@ -113,18 +116,19 @@ func TestTypeAliases(t *testing.T) {
 		t.Errorf("TypeWithOptionalFieldAtRequired alias = %v, want %v", atReq, id)
 	}
 
-	// TypeWithAllOfIDAllOf0 is an alias for googleuuid.UUID
-	var allOf0 TypeWithAllOfIDAllOf0 = id
-	if allOf0 != id {
-		t.Errorf("TypeWithAllOfIDAllOf0 alias = %v, want %v", allOf0, id)
+	// TypeWithAllOfID is now an alias for googleuuid.UUID (after allOf extension merge fix)
+	var allOfID TypeWithAllOfID = id
+	if allOfID != id {
+		t.Errorf("TypeWithAllOfID alias = %v, want %v", allOfID, id)
 	}
 }
 
 // TestApplyDefaults verifies ApplyDefaults does not panic on all types.
 func TestApplyDefaults(t *testing.T) {
 	(&TypeWithOptionalField{}).ApplyDefaults()
 	(&TypeWithAllOf{}).ApplyDefaults()
-	(&TypeWithAllOfID{}).ApplyDefaults()
+	// TypeWithAllOfID is now a type alias (= googleuuid.UUID), not a struct,
+	// so it does not have ApplyDefaults.
 }
 
 // TestGetOpenAPISpecJSON verifies the embedded spec can be decoded.

experimental/codegen/internal/test/previous_version/issues/issue_1957/output/types_test.go

@@ -570,6 +570,32 @@ func (g *TypeGenerator) GenerateStructFields(desc *SchemaDescriptor) []StructFie
 			}
 		}
 
+		// Merge extensions from allOf member descriptors for this property.
+		// Mirrors V2's MergeSchemas: allOf member extensions apply to the field.
+		if propDesc, ok := desc.Properties[propName]; ok && len(propDesc.AllOf) > 0 {
+			for _, member := range propDesc.AllOf {
+				if member == nil {
+					continue
+				}
+				// For $ref allOf members, merge the target's extensions
+				if member.IsReference() {
+					if target, ok := g.schemaIndex[member.Ref]; ok && target.Extensions != nil {
+						if propExtensions == nil {
+							propExtensions = &Extensions{}
+						}
+						mergeExtensions(propExtensions, target.Extensions)
+					}
+				}
+				// Merge the member descriptor's own extensions
+				if member.Extensions != nil {
+					if propExtensions == nil {
+						propExtensions = &Extensions{}
+					}
+					mergeExtensions(propExtensions, member.Extensions)
+				}
+			}
+		}
+
 		// Apply extensions to the field
 		if propExtensions != nil {
 			// Name override