init()

in Sources/MockoloFramework/Utils/SwiftType.swift [551:686]
95 lines of code
22 McCabe index (conditional complexity)

    init(typeSyntax: TypeSyntax) {
        switch typeSyntax.as(TypeSyntaxEnum.self) {
        case .arrayType(let syntax):
            // [T]
            let elementType = SwiftType(typeSyntax: syntax.element)
            self.kind = .nominal(.init(name: .arrayTypeSugarName, genericParameterTypes: [elementType]))

        case .inlineArrayType(let syntax):
            // [N of T] - InlineArray type sugar (SE-0453, Swift 6.2+)
            // This case was added for swift-syntax 602 compatibility.
            // Full support (default value generation, etc.) is not implemented.
            // The type is preserved verbatim; users must provide their own default values.
            self.kind = .nominal(.init(name: syntax.trimmedDescription))

        case .dictionaryType(let syntax):
            // [T: U]
            let keyType = SwiftType(typeSyntax: syntax.key)
            let valueType = SwiftType(typeSyntax: syntax.value)
            self.kind = .nominal(.init(name: .dictionaryTypeSugarName, genericParameterTypes: [keyType, valueType]))

        case .tupleType(let syntax):
            // (T, u: U)
            let elements = syntax.elements.map {
                SwiftType.Tuple.Element(
                    label: $0.firstName?.text, // Tuple element cannot have two labels
                    type: SwiftType(typeSyntax: $0.type)
                )
            }
            self.kind = .tuple(.init(elements: elements))

        case .functionType(let syntax):
            // (T) -> U
            self.kind = .closure(.init(
                isAsync: syntax.effectSpecifiers?.asyncSpecifier != nil,
                throwing: ThrowingKind(syntax.effectSpecifiers?.throwsClause),
                arguments: syntax.parameters.map {
                    .init(
                        firstName: $0.firstName?.text,
                        secondName: $0.secondName?.text,
                        type: .init(typeSyntax: $0.type)
                    )
                },
                returning: SwiftType(typeSyntax: syntax.returnClause.type)
            ))

        case .optionalType(let syntax):
            // T?
            let base = SwiftType(typeSyntax: syntax.wrappedType)
            self = base.optionalWrapped()

        case .implicitlyUnwrappedOptionalType(let syntax):
            // T!
            let base = SwiftType(typeSyntax: syntax.wrappedType)
            self = base.optionalWrapped()
            self.isIUO = true

        case .identifierType(let syntax):
            // T<U>
            let name = syntax.name.trimmedDescription
            let generics = syntax.genericArgumentClause?.arguments.compactMap {
                $0.argument.as(TypeSyntax.self).flatMap {
                    SwiftType(typeSyntax: $0)
                }
            }
            self.kind = .nominal(.init(name: name, genericParameterTypes: generics ?? []))

        case .someOrAnyType(let syntax):
            // some P, any P
            self = SwiftType(typeSyntax: syntax.constraint)
            self.someOrAny = switch syntax.someOrAnySpecifier.tokenKind {
            case .keyword(.some): .some
            case .keyword(.any): .any
            default: nil
            }

        case .metatypeType(let syntax):
            // T.Type, P.Protocol
            let base = SwiftType(typeSyntax: syntax.baseType)
            self.kind = .nominal(.init(
                namespace: base,
                name: syntax.metatypeSpecifier.text
            ))

        case .memberType(let syntax):
            // T.U
            let name = syntax.name.trimmedDescription
            let generics = syntax.genericArgumentClause?.arguments.compactMap {
                $0.argument.as(TypeSyntax.self).flatMap {
                    SwiftType(typeSyntax: $0)
                }
            }
            self.kind = .nominal(.init(
                namespace: SwiftType(typeSyntax: syntax.baseType),
                name: name,
                genericParameterTypes: generics ?? []
            ))

        case .attributedType(let syntax):
            // inout T, sending T, @escaping T
            self = SwiftType(typeSyntax: syntax.baseType)
            self.attributes += syntax.specifiers.map(\.trimmedDescription)
            self.attributes += syntax.attributes.map(\.trimmedDescription)

        case .compositionType(let syntax):
            // P & Q
            let elements = syntax.elements.map { SwiftType(typeSyntax: $0.type) }
            self.kind = .composition(.init(elements: elements))

        case .namedOpaqueReturnType(let syntax):
            // <U>A
            // unsupported
            self.kind = .nominal(.init(name: syntax.trimmedDescription))

        case .packElementType(let syntax):
            // each T
            self = SwiftType(typeSyntax: syntax.pack)
            self.attributes.append("each")

        case .packExpansionType(let syntax):
            // repeat T
            self = SwiftType(typeSyntax: syntax.repetitionPattern)
            self.attributes.insert("repeat", at: 0)

        case .suppressedType(let syntax):
            // unsupported
            self = .init(typeSyntax: syntax.type)

        case .classRestrictionType(let syntax):
            // unsupported
            self.kind = .nominal(.init(name: syntax.trimmedDescription))

        case .missingType(let syntax):
            // unsupported
            self.kind = .nominal(.init(name: syntax.trimmedDescription))
        }
    }