Use generated Codable implementation for TypeDescription (#8)

Author: dfed

Sources/SafeDICore/Models/TypeDescription.swift

@@ -125,154 +125,6 @@ public enum TypeDescription: Codable, Hashable, Comparable, Sendable {
         }
     }
 
-    public init(from decoder: Decoder) throws {
-        let values = try decoder.container(keyedBy: CodingKeys.self)
-        let caseDescription = try values.decode(String.self, forKey: .caseDescription)
-        switch caseDescription {
-        case Self.simpleDescription:
-            let text = try values.decode(String.self, forKey: .text)
-            let typeDescriptions = try values.decode([Self].self, forKey: .typeDescriptions)
-            self = .simple(name: text, generics: typeDescriptions)
-
-        case Self.unknownDescription:
-            let text = try values.decode(String.self, forKey: .text)
-            self = .unknown(text: text)
-
-        case Self.nestedDescription:
-            let text = try values.decode(String.self, forKey: .text)
-            let parentType = try values.decode(Self.self, forKey: .typeDescription)
-            let typeDescriptions = try values.decode([Self].self, forKey: .typeDescriptions)
-            self = .nested(name: text, parentType: parentType, generics: typeDescriptions)
-
-        case Self.optionalDescription:
-            let typeDescription = try values.decode(Self.self, forKey: .typeDescription)
-            self = .optional(typeDescription)
-
-        case Self.implicitlyUnwrappedOptionalDescription:
-            let typeDescription = try values.decode(Self.self, forKey: .typeDescription)
-            self = .implicitlyUnwrappedOptional(typeDescription)
-
-        case Self.compositionDescription:
-            let typeDescriptions = try values.decode([Self].self, forKey: .typeDescriptions)
-            self = .composition(typeDescriptions)
-
-        case Self.someDescription:
-            let typeDescription = try values.decode(Self.self, forKey: .typeDescription)
-            self = .some(typeDescription)
-
-        case Self.anyDescription:
-            let typeDescription = try values.decode(Self.self, forKey: .typeDescription)
-            self = .any(typeDescription)
-
-        case Self.metatypeDescription:
-            let typeDescription = try values.decode(Self.self, forKey: .typeDescription)
-            let isType = try values.decode(Bool.self, forKey: .isType)
-            self = .metatype(typeDescription, isType: isType)
-
-        case Self.attributedDescription:
-            let typeDescription = try values.decode(Self.self, forKey: .typeDescription)
-            let specifier = try values.decodeIfPresent(String.self, forKey: .specifier)
-            let attributes = try values.decodeIfPresent([String].self, forKey: .attributes)
-            self = .attributed(typeDescription, specifier: specifier, attributes: attributes)
-
-        case Self.arrayDescription:
-            let typeDescription = try values.decode(Self.self, forKey: .typeDescription)
-            self = .array(element: typeDescription)
-
-        case Self.dictionaryDescription:
-            let key = try values.decode(Self.self, forKey: .dictionaryKey)
-            let value = try values.decode(Self.self, forKey: .dictionaryValue)
-            self = .dictionary(key: key, value: value)
-
-        case Self.tupleDescription:
-            let typeDescriptions = try values.decode([Self].self, forKey: .typeDescriptions)
-            self = .tuple(typeDescriptions)
-
-        case Self.closureDescription:
-            let typeDescriptions = try values.decode([Self].self, forKey: .closureArguments)
-            let isAsync = try values.decode(Bool.self, forKey: .closureIsAsync)
-            let doesThrow = try values.decode(Bool.self, forKey: .closureThrows)
-            let typeDescription = try values.decode(Self.self, forKey: .closureReturn)
-            self = .closure(arguments: typeDescriptions, isAsync: isAsync, doesThrow: doesThrow, returnType: typeDescription)
-
-        default:
-            throw CodingError.unknownCase
-        }
-    }
-
-    public func encode(to encoder: Encoder) throws {
-        var container = encoder.container(keyedBy: CodingKeys.self)
-        try container.encode(caseDescription, forKey: .caseDescription)
-        switch self {
-        case let .simple(name, generics):
-            try container.encode(name, forKey: .text)
-            try container.encode(generics, forKey: .typeDescriptions)
-        case let .unknown(text):
-            try container.encode(text, forKey: .text)
-        case let .optional(type),
-            let .implicitlyUnwrappedOptional(type),
-            let .array(type),
-            let .some(type),
-            let .any(type):
-            try container.encode(type, forKey: .typeDescription)
-        case let .tuple(types),
-            let .composition(types):
-            try container.encode(types, forKey: .typeDescriptions)
-        case let .metatype(type, isType):
-            try container.encode(type, forKey: .typeDescription)
-            try container.encode(isType, forKey: .isType)
-        case let .attributed(type, specifier: specifier, attributes: attributes):
-            try container.encode(type, forKey: .typeDescription)
-            try container.encodeIfPresent(specifier, forKey: .specifier)
-            try container.encodeIfPresent(attributes, forKey: .attributes)
-        case let .nested(name, parentType, generics):
-            try container.encode(name, forKey: .text)
-            try container.encode(parentType, forKey: .typeDescription)
-            try container.encode(generics, forKey: .typeDescriptions)
-        case let .dictionary(key, value):
-            try container.encode(key, forKey: .dictionaryKey)
-            try container.encode(value, forKey: .dictionaryValue)
-        case let .closure(arguments, isAsync, doesThrow, returnType):
-            try container.encode(arguments, forKey: .closureArguments)
-            try container.encode(isAsync, forKey: .closureIsAsync)
-            try container.encode(doesThrow, forKey: .closureThrows)
-            try container.encode(returnType, forKey: .closureReturn)
-        }
-    }
-
-    enum CodingKeys: String, CodingKey {
-        /// The value for this key is the case encoded as a String.
-        case caseDescription
-        /// The value for this key is an associated value of type String
-        case text
-        /// The value for this key is the associated value of type TypeDescription
-        case typeDescription
-        /// The value for this key is the associated value of type [TypeDescription]
-        case typeDescriptions
-        /// The value for this key represents whether a metatype is a Type (as opposed to a Protocol) and is of type Bool
-        case isType
-        /// The value for this key is the specifier on an attributed type of type String
-        case specifier
-        /// The value for this key is the attributes on an attributed type of type [String]
-        case attributes
-        /// The value for this key is a dictionary's key of type TypeDescription
-        case dictionaryKey
-        /// The value for this key is a dictionary's value of type TypeDescription
-        case dictionaryValue
-        /// The value for this key represents the list of types in a closure argument list and is of type [TypeDescription]
-        case closureArguments
-        /// The value for this key represents whether a closure is `async` and is of type Bool
-        case closureIsAsync
-        /// The value for this key represents whether a closure `throws` and is of type Bool
-        case closureThrows
-        /// The value for this key represents the return type of a closure argument list and is of type TypeDescription
-        case closureReturn
-    }
-
-    public enum CodingError: Error {
-        case unknownCase
-    }
-
     public static func < (lhs: TypeDescription, rhs: TypeDescription) -> Bool {
         lhs.asSource < rhs.asSource
     }
@@ -343,54 +195,6 @@ public enum TypeDescription: Codable, Hashable, Comparable, Sendable {
             return self
         }
     }
-
-    private var caseDescription: String {
-        switch self {
-        case .composition:
-            return Self.compositionDescription
-        case .implicitlyUnwrappedOptional:
-            return Self.implicitlyUnwrappedOptionalDescription
-        case .nested:
-            return Self.nestedDescription
-        case .optional:
-            return Self.optionalDescription
-        case .simple:
-            return Self.simpleDescription
-        case .some:
-            return Self.someDescription
-        case .any:
-            return Self.anyDescription
-        case .metatype:
-            return Self.metatypeDescription
-        case .attributed:
-            return Self.attributedDescription
-        case .array:
-            return Self.arrayDescription
-        case .dictionary:
-            return Self.dictionaryDescription
-        case .tuple:
-            return Self.tupleDescription
-        case .closure:
-            return Self.closureDescription
-        case .unknown:
-            return Self.unknownDescription
-        }
-    }
-
-    private static let simpleDescription = "simple"
-    private static let nestedDescription = "nested"
-    private static let compositionDescription = "composition"
-    private static let optionalDescription = "optional"
-    private static let implicitlyUnwrappedOptionalDescription = "implicitlyUnwrappedOptional"
-    private static let someDescription = "some"
-    private static let anyDescription = "any"
-    private static let metatypeDescription = "metatype"
-    private static let attributedDescription = "attributed"
-    private static let arrayDescription = "array"
-    private static let dictionaryDescription = "dictionary"
-    private static let tupleDescription = "tuple"
-    private static let closureDescription = "closure"
-    private static let unknownDescription = "unknown"
 }
 
 extension TypeSyntax {