expected-output.swift

extension Alpha {
    func copy(
        charlie: CopiableProp<Alpha.Bravo.Charlie> = .copy,
        optionalCharlie: NullableCopiableProp<Alpha.Bravo.Charlie> = .copy,
        charlieArray: CopiableProp<[Alpha.Bravo.Charlie]> = .copy,
        optionalCharlieArray: NullableCopiableProp<[Alpha.Bravo.Charlie]> = .copy,
        bravoArray: CopiableProp<[Alpha.Bravo]> = .copy,
        optionalBravoArray: NullableCopiableProp<[Alpha.Bravo]> = .copy,
        stringProp: CopiableProp<String> = .copy,
        optionalStringProp: NullableCopiableProp<String> = .copy,
        stringArray: CopiableProp<[String]> = .copy,
        optionalStringArray: NullableCopiableProp<[String]> = .copy,
        dictionary: CopiableProp<[String: Alpha.Bravo]> = .copy,
        optionalDictionary: NullableCopiableProp<[String: Alpha.Delta]> = .copy,
        nestedCharlieArray: CopiableProp<[[Alpha.Bravo.Charlie]]> = .copy
    ) -> Alpha {
        let charlie = charlie ?? self.charlie
        let optionalCharlie = optionalCharlie ?? self.optionalCharlie
        let charlieArray = charlieArray ?? self.charlieArray
        let optionalCharlieArray = optionalCharlieArray ?? self.optionalCharlieArray
        let bravoArray = bravoArray ?? self.bravoArray
        let optionalBravoArray = optionalBravoArray ?? self.optionalBravoArray
        let stringProp = stringProp ?? self.stringProp
        let optionalStringProp = optionalStringProp ?? self.optionalStringProp
        let stringArray = stringArray ?? self.stringArray
        let optionalStringArray = optionalStringArray ?? self.optionalStringArray
        let dictionary = dictionary ?? self.dictionary
        let optionalDictionary = optionalDictionary ?? self.optionalDictionary
        let nestedCharlieArray = nestedCharlieArray ?? self.nestedCharlieArray

        return Alpha(
            charlie: charlie,
            optionalCharlie: optionalCharlie,
            charlieArray: charlieArray,
            optionalCharlieArray: optionalCharlieArray,
            bravoArray: bravoArray,
            optionalBravoArray: optionalBravoArray,
            stringProp: stringProp,
            optionalStringProp: optionalStringProp,
            stringArray: stringArray,
            optionalStringArray: optionalStringArray,
            dictionary: dictionary,
            optionalDictionary: optionalDictionary,
            nestedCharlieArray: nestedCharlieArray
        )
    }
}

extension Alpha.Echo {
    func copy(
        bravo: CopiableProp<Alpha.Bravo> = .copy,
        bravoArray: CopiableProp<[Alpha.Bravo]> = .copy,
        charlie: CopiableProp<Alpha.Bravo.Charlie> = .copy,
        delta: CopiableProp<Alpha.Delta> = .copy,
        optionalDelta: NullableCopiableProp<Alpha.Delta> = .copy,
        deltaArray: CopiableProp<[Alpha.Delta]> = .copy,
        optionalDeltaArray: NullableCopiableProp<[Alpha.Delta]> = .copy,
        dictionary: CopiableProp<[Int64: Alpha.Bravo]> = .copy
    ) -> Alpha.Echo {
        let bravo = bravo ?? self.bravo
        let bravoArray = bravoArray ?? self.bravoArray
        let charlie = charlie ?? self.charlie
        let delta = delta ?? self.delta
        let optionalDelta = optionalDelta ?? self.optionalDelta
        let deltaArray = deltaArray ?? self.deltaArray
        let optionalDeltaArray = optionalDeltaArray ?? self.optionalDeltaArray
        let dictionary = dictionary ?? self.dictionary

        return Alpha.Echo(
            bravo: bravo,
            bravoArray: bravoArray,
            charlie: charlie,
            delta: delta,
            optionalDelta: optionalDelta,
            deltaArray: deltaArray,
            optionalDeltaArray: optionalDeltaArray,
            dictionary: dictionary
        )
    }
}

testdata.swift

import Networking

struct Alpha: GeneratedCopiable {
    struct Bravo {
        struct Charlie {
            let name: String
        }
    }

    enum Delta {
        case one
        case two
    }

    let charlie: Bravo.Charlie
    let optionalCharlie: Bravo.Charlie?
    let charlieArray: [Bravo.Charlie]
    let optionalCharlieArray: [Bravo.Charlie]?
    let bravoArray: [Bravo]
    let optionalBravoArray: [Bravo]?
    let stringProp: String
    let optionalStringProp: String?
    let stringArray: [String]
    let optionalStringArray: [String]?
    let dictionary: [String: Bravo]
    let optionalDictionary: [String: Delta]?
    let nestedCharlieArray: [[Bravo.Charlie]]

    struct Echo: GeneratedCopiable {
        let bravo: Bravo
        let bravoArray: [Bravo]
        let charlie: Bravo.Charlie
        let delta: Delta
        let optionalDelta: Delta?
        let deltaArray: [Delta]
        let optionalDeltaArray: [Delta]?
        let dictionary: [Int64: Bravo]
    }
}