[codex] Fix nested generic specialization ownership

[Kyle-Ye]

Summary

• Add a TypeDefinition specialization path that derives nested specialized child types from an outer generic specialization.
• Preserve manually-created nested specializations on their original generic child instead of moving them under the outer specialized node.
• Extend recursive field dumping so optional payload metadata can be expanded in specialized descriptions.

Root Cause

RuntimeViewer needs to specialize nested Swift generic types such as EventListenerPhase<A>.Value after specializing the outer generic type. The previous model either copied/moved child specializations through the outer specialization path or lacked enough nested derivation information, which made separately-created nested specializations unstable.

Validation

• swift test --package-path MachOSwiftSection --filter GenericTypeNameSubstitutionEndToEndTests
• swift test --package-path MachOSwiftSection --filter SpecializedDumperFieldTypeTests

Companion RuntimeViewer PR will consume this SPI and preserve the sidebar tree identity.

[Copilot]

Pull request overview

Note

Copilot was unable to run its full agentic suite in this review.

Extends generic specialization support to derive nested specialized child TypeDefinitions from an outer specialization, and improves dump output for expanded field offsets by recursing through Optional/enum payload metadata.

Changes:

• Add a TypeDefinition.specialize(...) SPI overload that can derive nested specialized children during specialization.
• Enhance TypedDumper expanded field-offset recursion to handle Optional/enum payload metadata, not just structs.
• Add new fixtures and tests covering nested derivation behavior and Optional payload recursion.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
Tests/SwiftInterfaceTests/GenericTypeNameSubstitutionTests.swift	Adds an end-to-end test validating derived nested child specializations and preserving existing manual nested specializations.
Tests/SwiftInterfaceTests/GenericSpecializationTests.swift	Adds a new nested generic fixture type used to exercise nested derivation rules.
Tests/MachOSwiftSectionTests/SpecializedDumperFieldTypeTests.swift	Adds a test ensuring expanded field offsets recurse through Optional payload metadata.
Sources/SwiftInterface/Components/Definitions/TypeDefinition.swift	Introduces a specialization path that derives nested specialized children and adds the nested-derivation routine.
Sources/SwiftDump/Protocols/TypedDumper.swift	Refactors expanded field-offset walking to dispatch by metadata kind (struct vs enum/optional).

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[gemini-code-assist]

Code Review

This pull request adds support for recursing through Optional and enum payload metadata during field offset dumping, and introduces recursive specialization of nested generic child types. Feedback is provided on TypeDefinition.swift to wrap the nested child specialization loop in a do-catch block, preventing a single child specialization failure from failing the entire outer type's specialization.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

If any nested child type fails to specialize (for example, due to unsupported generic parameters or a constraint mismatch), the entire deriveNestedSpecializedTypeChildren call will throw and fail the specialization of the outer type. Wrapping the inner loop body in a do-catch block and skipping the failed child allows the outer type and other valid nested types to still be specialized and displayed successfully.

        for child in typeChildren {
            guard child.type.typeContextDescriptorWrapper.typeContextDescriptor.layout.flags.isGeneric else {
                continue
            }

            do {
                let request = try specializer.makeRequest(for: child.type.typeContextDescriptorWrapper)
                var childArguments: [String: SpecializationSelection.Argument] = [:]
                var childArgumentNodes: [Node] = []
                var childNodesByParameter: [String: Node] = [:]
                var hasCompleteBinding = true

                for parameter in request.parameters {
                    guard let argument = selection.arguments[parameter.name],
                          let node = typeArgumentNodesByParameter[parameter.name]
                    else {
                        hasCompleteBinding = false
                        break
                    }
                    childArguments[parameter.name] = argument
                    childArgumentNodes.append(node)
                    childNodesByParameter[parameter.name] = node
                }

                guard hasCompleteBinding else {
                    continue
                }

                let childSelection = SpecializationSelection(arguments: childArguments)
                let childResult = try specializer.specialize(request, with: childSelection)
                let effectiveChildArgumentNodes = childArgumentNodes.isEmpty
                    ? inheritedTypeArgumentNodes
                    : childArgumentNodes
                let childSpecialized = try child.makeSpecializedDefinition(
                    with: childResult,
                    typeArgumentNodes: effectiveChildArgumentNodes,
                    in: machO
                )
                childSpecialized.typeChildren = try await child.deriveNestedSpecializedTypeChildren(
                    using: specializer,
                    selection: childSelection,
                    typeArgumentNodesByParameter: childNodesByParameter,
                    inheritedTypeArgumentNodes: effectiveChildArgumentNodes,
                    in: machO,
                    depth: depth + 1
                )
                for grandchild in childSpecialized.typeChildren {
                    grandchild.parent = childSpecialized
                }
                derivedChildren.append(childSpecialized)
            } catch {
                continue
            }
        }