override fun getFieldDescriptorTraits()

in smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/serde/XmlSerdeDescriptorGenerator.kt [64:141]
65 lines of code
8 McCabe index (conditional complexity)

    override fun getFieldDescriptorTraits(
        member: MemberShape,
        targetShape: Shape,
        nameSuffix: String
    ): List<SdkFieldDescriptorTrait> {

        ctx.writer.addImport(
            RuntimeTypes.Serde.SerdeXml.XmlDeserializer,
            RuntimeTypes.Serde.SerdeXml.XmlSerialName,
        )

        val traitList = mutableListOf<SdkFieldDescriptorTrait>()

        val serialName = getSerialName(member, nameSuffix)
        traitList.add(SerdeXml.XmlSerialName, serialName.dq())

        val memberTarget = ctx.model.expectShape(member.target)
        val isNestedMap = memberTarget.isMapShape && targetShape.isMapShape && nameSuffix.isNotEmpty()
        val flattened = member.getTrait<XmlFlattenedTrait>()?.also {
            if (!isNestedMap) {
                traitList.add(it.toSdkTrait())
            }
        } != null
        member.getTrait<XmlAttributeTrait>()?.let { traitList.add(it.toSdkTrait()) }
        member.getTrait<XmlNamespaceTrait>()?.let { traitList.add(it.toSdkTrait()) }

        when (targetShape.type) {
            ShapeType.LIST, ShapeType.SET -> {
                val collectionMember = (targetShape as CollectionShape).member
                if (!flattened && collectionMember.hasTrait<XmlNameTrait>()) {
                    // flattened collections should only need the XmlSerialName trait since there is no <member> element
                    val memberName = collectionMember.expectTrait<XmlNameTrait>().value
                    traitList.add(SerdeXml.XmlCollectionName, memberName.dq())
                }

                if (collectionMember.hasTrait<XmlNamespaceTrait>()) {
                    val ns = collectionMember.expectTrait<XmlNamespaceTrait>()
                    val nsTrait = ns.toSdkTrait(SerdeXml.XmlCollectionValueNamespace)
                    traitList.add(nsTrait)
                }
            }
            ShapeType.MAP -> {
                val mapMember = targetShape as MapShape

                val customKeyName = mapMember.key.getTrait<XmlNameTrait>()?.value
                val customValueName = mapMember.value.getTrait<XmlNameTrait>()?.value

                val mapTraitArgs = when {
                    customKeyName != null && customValueName != null -> listOf("key = ${customKeyName.dq()}", "value = ${customValueName.dq()}")
                    customKeyName != null -> listOf("key = ${customKeyName.dq()}")
                    customValueName != null -> listOf("value = ${customValueName.dq()}")
                    else -> null
                }

                mapTraitArgs?.let {
                    traitList.add(SerdeXml.XmlMapName, *it.toTypedArray())
                    writer.addImport(SerdeXml.XmlMapName)
                }

                mapMember.key
                    .getTrait<XmlNamespaceTrait>()
                    ?.toSdkTrait(SerdeXml.XmlMapKeyNamespace)
                    ?.let {
                        traitList.add(it)
                    }

                mapMember.value
                    .getTrait<XmlNamespaceTrait>()
                    ?.toSdkTrait(SerdeXml.XmlCollectionValueNamespace)
                    ?.let {
                        traitList.add(it)
                    }
            }
            else -> { } // No action needed
        }

        return traitList
    }