func parseNakedType()

in Sources/SIL/SILParser.swift [577:634]
47 lines of code
12 McCabe index (conditional complexity)

    func parseNakedType() throws -> Type {
        if skip("<") {
            var params = [String]()
            while true {
                let name = try parseTypeName()
                params.append(name)
                guard !peek("where") && !peek(">") else { break }
                try take(",")
            }
            let reqs: [TypeRequirement]
            if peek("where") {
                reqs = try parseMany("where", ",", ">") { try parseTypeRequirement() }
            } else {
                reqs = []
                try take(">")
            }
            let type = try parseNakedType()
            return .genericType(params, reqs, type)
        } else if peek("@") {
            let attrs = try parseMany("@") { try parseTypeAttribute() }
            let type = try parseNakedType()
            return .attributedType(attrs, type)
        } else if skip("*") {
            let type = try parseNakedType()
            return .addressType(type)
        } else if skip("[") {
            let subtype = try parseNakedType()
            try take("]")
            return .specializedType(.namedType("Array"), [subtype])
        } else if peek("(") {
            let types = try parseMany("(", ",", ")") { try parseNakedType() }
            if skip("->") {
                let result = try parseNakedType()
                return .functionType(types, result)
            } else {
                if types.count == 1 {
                    return types[0]
                } else {
                    return .tupleType(types)
                }
            }
        } else {
            func grow(_ type: Type) throws -> Type {
                if peek("<") {
                    let types = try parseMany("<", ",", ">") { try parseNakedType() }
                    return try grow(.specializedType(type, types))
                } else if skip(".") {
                    let name = try parseTypeName()
                    return try grow(.selectType(type, name))
                } else {
                    return type
                }
            }
            let name = try parseTypeName()
            let base: Type = name != "Self" ? .namedType(name) : .selfType
            return try grow(base)
        }
    }