feat: added support for Encodable/Decodable partial conformance (#137)

Author: soumyamahunt

.swift-format

@@ -1,18 +1,62 @@
 {
     "version": 1,
     "lineLength": 80,
+    "tabWidth": 4,
     "indentation": {
         "spaces": 4
     },
+    "fileScopedDeclarationPrivacy": {
+        "accessLevel": "private"
+    },
     "maximumBlankLines": 1,
     "respectsExistingLineBreaks": true,
     "indentConditionalCompilationBlocks": false,
+    "lineBreakBetweenDeclarationAttributes": true,
+    "multiElementCollectionTrailingCommas": true,
+    "prioritizeKeepingFunctionOutputTogether": true,
+    "spacesAroundRangeFormationOperators": false,
     "rules": {
         "AllPublicDeclarationsHaveDocumentation": true,
+        "AlwaysUseLiteralForEmptyCollectionInit": true,
+        "AlwaysUseLowerCamelCase": true,
+        "AmbiguousTrailingClosureOverload": true,
+        "BeginDocumentationCommentWithOneLineSummary": false,
+        "DoNotUseSemicolons": true,
+        "DontRepeatTypeInStaticProperties": true,
+        "FileScopedDeclarationPrivacy": true,
+        "FullyIndirectEnum": true,
+        "GroupNumericLiterals": true,
+        "IdentifiersMustBeASCII": true,
         "NeverForceUnwrap": true,
         "NeverUseForceTry": true,
+        "NeverUseImplicitlyUnwrappedOptionals": false,
         "NoAccessLevelOnExtensionDeclaration": false,
+        "NoAssignmentInExpressions": true,
+        "NoBlockComments": true,
+        "NoCasesWithOnlyFallthrough": true,
+        "NoEmptyLinesOpeningClosingBraces": true,
+        "NoEmptyTrailingClosureParentheses": true,
+        "NoLabelsInCasePatterns": true,
+        "NoLeadingUnderscores": false,
+        "NoParensAroundConditions": true,
+        "NoPlaygroundLiterals": true,
+        "NoVoidReturnOnFunctionSignature": true,
+        "OmitExplicitReturns": true,
+        "OneCasePerLine": true,
+        "OneVariableDeclarationPerLine": true,
+        "OnlyOneTrailingClosureArgument": true,
         "OrderedImports": true,
+        "ReplaceForEachWithForLoop": true,
+        "ReturnVoidInsteadOfEmptyTuple": true,
+        "TypeNamesShouldBeCapitalized": true,
+        "UseEarlyExits": true,
+        "UseExplicitNilCheckInConditions": true,
+        "UseLetInEveryBoundCaseVariable": true,
+        "UseShorthandTypeNames": true,
+        "UseSingleLinePropertyGetter": true,
+        "UseSynthesizedInitializer": true,
+        "UseTripleSlashForDocumentationComments": true,
+        "UseWhereClausesInForLoops": true,
         "ValidateDocumentationComments": true
     }
 }

Sources/MacroPlugin/Definitions.swift

@@ -608,3 +608,121 @@ struct UnTagged: PeerMacro {
         )
     }
 }
+
+/// A declaration macro that generates `Decodable`
+/// protocol conformance.
+///
+/// This implementation will delegate to the plugin core
+/// implementation depending on the type of attached declaration:
+///   * `struct`/`class`/`enum`/`actor` types: Expansion of `Decodable`
+///     protocol conformance members.
+public struct ConformDecodable: MemberMacro, ExtensionMacro {
+    /// Expand to produce members for `Decodable`.
+    ///
+    /// Membership macro expansion for `ConformDecodable` macro
+    /// will delegate to `PluginCore.ConformDecodable`.
+    ///
+    /// - Parameters:
+    ///   - node: The custom attribute describing this attached macro.
+    ///   - declaration: The declaration this macro attribute is attached to.
+    ///   - context: The context in which to perform the macro expansion.
+    ///
+    /// - Returns: Delegated member expansion from `PluginCore.ConformDecodable`.
+    public static func expansion(
+        of node: AttributeSyntax,
+        providingMembersOf declaration: some DeclGroupSyntax,
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        return try PluginCore.ConformDecodable.expansion(
+            of: node, providingMembersOf: declaration, in: context
+        )
+    }
+
+    /// Expand to produce extensions for `Decodable`.
+    ///
+    /// Extension macro expansion for `ConformDecodable` macro
+    /// will delegate to `PluginCore.ConformDecodable`.
+    ///
+    /// - Parameters:
+    ///   - node: The custom attribute describing this attached macro.
+    ///   - declaration: The declaration this macro attribute is attached to.
+    ///   - type: The type to provide extensions of.
+    ///   - protocols: The list of protocols to add conformances to. These will
+    ///     always be protocols that `type` does not already state a conformance
+    ///     to.
+    ///   - context: The context in which to perform the macro expansion.
+    ///
+    /// - Returns: Delegated extension expansion from `PluginCore.ConformDecodable`.
+    public static func expansion(
+        of node: AttributeSyntax,
+        attachedTo declaration: some DeclGroupSyntax,
+        providingExtensionsOf type: some TypeSyntaxProtocol,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [ExtensionDeclSyntax] {
+        return try PluginCore.ConformDecodable.expansion(
+            of: node, attachedTo: declaration,
+            providingExtensionsOf: type, conformingTo: protocols,
+            in: context
+        )
+    }
+}
+
+/// A declaration macro that generates `Encodable`
+/// protocol conformance.
+///
+/// This implementation will delegate to the plugin core
+/// implementation depending on the type of attached declaration:
+///   * `struct`/`class`/`enum`/`actor` types: Expansion of `Encodable`
+///     protocol conformance members.
+public struct ConformEncodable: MemberMacro, ExtensionMacro {
+    /// Expand to produce members for `Encodable`.
+    ///
+    /// Membership macro expansion for `ConformEncodable` macro
+    /// will delegate to `PluginCore.ConformEncodable`.
+    ///
+    /// - Parameters:
+    ///   - node: The custom attribute describing this attached macro.
+    ///   - declaration: The declaration this macro attribute is attached to.
+    ///   - context: The context in which to perform the macro expansion.
+    ///
+    /// - Returns: Delegated member expansion from `PluginCore.ConformEncodable`.
+    public static func expansion(
+        of node: AttributeSyntax,
+        providingMembersOf declaration: some DeclGroupSyntax,
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        return try PluginCore.ConformEncodable.expansion(
+            of: node, providingMembersOf: declaration, in: context
+        )
+    }
+
+    /// Expand to produce extensions for `Encodable`.
+    ///
+    /// Extension macro expansion for `ConformEncodable` macro
+    /// will delegate to `PluginCore.ConformEncodable`.
+    ///
+    /// - Parameters:
+    ///   - node: The custom attribute describing this attached macro.
+    ///   - declaration: The declaration this macro attribute is attached to.
+    ///   - type: The type to provide extensions of.
+    ///   - protocols: The list of protocols to add conformances to. These will
+    ///     always be protocols that `type` does not already state a conformance
+    ///     to.
+    ///   - context: The context in which to perform the macro expansion.
+    ///
+    /// - Returns: Delegated extension expansion from `PluginCore.ConformEncodable`.
+    public static func expansion(
+        of node: AttributeSyntax,
+        attachedTo declaration: some DeclGroupSyntax,
+        providingExtensionsOf type: some TypeSyntaxProtocol,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [ExtensionDeclSyntax] {
+        return try PluginCore.ConformEncodable.expansion(
+            of: node, attachedTo: declaration,
+            providingExtensionsOf: type, conformingTo: protocols,
+            in: context
+        )
+    }
+}

Sources/MacroPlugin/Plugin.swift

@@ -21,6 +21,8 @@ struct MetaCodablePlugin: CompilerPlugin {
         IgnoreDecoding.self,
         IgnoreEncoding.self,
         Codable.self,
+        ConformDecodable.self,
+        ConformEncodable.self,
         MemberInit.self,
         CodingKeys.self,
         IgnoreCodingInitialized.self,

Sources/MetaCodable/Codable/Decodable.swift

@@ -0,0 +1,57 @@
+/// Generate `Decodable` implementation of `struct`, `class`, `enum`, `actor`
+/// and `protocol` types by leveraging custom attributes provided on variable
+/// declarations. This macro is named `ConformDecodable` to avoid conflicts
+/// with the standard library `Decodable` protocol.
+///
+/// # Usage
+/// By default the field name is used as `CodingKey` for the field value during
+/// decoding. Following customization can be done on fields to
+/// provide custom decode behavior:
+///   * Use ``CodedAt(_:)`` providing single string value as custom coding key.
+///   * Use ``CodedAt(_:)`` providing multiple string value as nested coding
+///     key path.
+///   * Use ``CodedIn(_:)`` with one or more string value as nested container
+///     coding key path, with variable name as coding key.
+///   * Use ``CodedAt(_:)`` with no path arguments, when type is composition
+///     of multiple `Decodable` types.
+///   * Use ``CodedBy(_:)`` to provide custom decoding behavior for
+///     `Decodable` types or implement decoding for non-`Decodable` types.
+///   * Use ``Default(_:)`` to provide default value when decoding fails.
+///   * Use ``CodedAs(_:_:)`` to provide custom values for enum cases.
+///   * Use ``CodedAt(_:)`` to provide enum-case/protocol identifier tag path.
+///   * Use ``CodedAs()`` to provide enum-case/protocol identifier tag type.
+///   * Use ``ContentAt(_:_:)`` to provided enum-case/protocol content path.
+///   * Use ``IgnoreCoding()``, ``IgnoreDecoding()`` to ignore specific 
+///     properties/cases/types from decoding.
+///   * Use ``CodingKeys(_:)`` to work with different case style `CodingKey`s.
+///   * Use ``IgnoreCodingInitialized()`` to ignore decoding
+///     all initialized properties/case associated variables.
+///
+/// # Effect
+/// This macro composes extension macro expansion for `Decodable`
+/// conformance of type:
+///   * Extension macro expansion, to confirm to `Decodable` protocol
+///     if the type doesn't already conform to `Decodable`.
+///   * Extension macro expansion, to generate custom `CodingKey` type for
+///     the attached declaration named `CodingKeys` and use this type for
+///     `Decodable` implementation of `init(from:)` method.
+///   * If attached declaration already conforms to `Decodable` this macro expansion
+///     is skipped.
+///
+/// - Parameters:
+///   - commonStrategies: An array of CodableCommonStrategy values specifying
+///   type conversion strategies to be automatically applied to all properties of the type.
+///
+/// - Important: The attached declaration must be of a `struct`, `class`, `enum`
+///   or `actor` type. [See the limitations for this macro](<doc:Limitations>).
+@attached(
+    extension, conformances: Decodable,
+    names: named(CodingKeys), named(DecodingKeys), named(init(from:))
+)
+@attached(
+    member, conformances: Decodable,
+    names: named(CodingKeys), named(init(from:))
+)
+@available(swift 5.9)
+public macro ConformDecodable(commonStrategies: [CodableCommonStrategy] = []) =
+    #externalMacro(module: "MacroPlugin", type: "ConformDecodable")

Sources/MetaCodable/Codable/Encodable.swift

@@ -0,0 +1,60 @@
+/// Generate `Encodable` implementation of `struct`, `class`, `enum`, `actor`
+/// and `protocol` types by leveraging custom attributes provided on variable
+/// declarations. This macro is named `ConformEncodable` to avoid conflicts
+/// with the standard library `Encodable` protocol.
+///
+/// # Usage
+/// By default the field name is used as `CodingKey` for the field value during
+/// encoding. Following customization can be done on fields to
+/// provide custom encode behavior:
+///   * Use ``CodedAt(_:)`` providing single string value as custom coding key.
+///   * Use ``CodedAt(_:)`` providing multiple string value as nested coding
+///     key path.
+///   * Use ``CodedIn(_:)`` with one or more string value as nested container
+///     coding key path, with variable name as coding key.
+///   * Use ``CodedAt(_:)`` with no path arguments, when type is composition
+///     of multiple `Encodable` types.
+///   * Use ``CodedAs(_:_:)`` to provide additional coding key values where
+///     field value can appear.
+///   * Use ``CodedBy(_:)`` to provide custom encoding behavior for
+///     `Encodable` types or implement encoding for non-`Encodable` types.
+///   * Use ``CodedAs(_:_:)`` to provide custom values for enum cases.
+///   * Use ``CodedAt(_:)`` to provide enum-case/protocol identifier tag path.
+///   * Use ``CodedAs()`` to provide enum-case/protocol identifier tag type.
+///   * Use ``ContentAt(_:_:)`` to provided enum-case/protocol content path.
+///   * Use ``IgnoreCoding()``, ``IgnoreEncoding()`` to ignore specific 
+///     properties/cases/types from encoding.
+///   * Use ``IgnoreEncoding(if:)-1iuvv`` and ``IgnoreEncoding(if:)-7toka``
+///     to ignore encoding based on custom conditions.
+///   * Use ``CodingKeys(_:)`` to work with different case style `CodingKey`s.
+///   * Use ``IgnoreCodingInitialized()`` to ignore encoding
+///     all initialized properties/case associated variables.
+///
+/// # Effect
+/// This macro composes extension macro expansion for `Encodable`
+/// conformance of type:
+///   * Extension macro expansion, to confirm to `Encodable` protocol
+///     if the type doesn't already conform to `Encodable`.
+///   * Extension macro expansion, to generate custom `CodingKey` type for
+///     the attached declaration named `CodingKeys` and use this type for
+///     `Encodable` implementation of `encode(to:)` method.
+///   * If attached declaration already conforms to `Encodable` this macro expansion
+///     is skipped.
+///
+/// - Parameters:
+///   - commonStrategies: An array of CodableCommonStrategy values specifying
+///   type conversion strategies to be automatically applied to all properties of the type.
+///
+/// - Important: The attached declaration must be of a `struct`, `class`, `enum`
+///   or `actor` type. [See the limitations for this macro](<doc:Limitations>).
+@attached(
+    extension, conformances: Encodable,
+    names: named(CodingKeys), named(encode(to:))
+)
+@attached(
+    member, conformances: Encodable,
+    names: named(CodingKeys), named(encode(to:))
+)
+@available(swift 5.9)
+public macro ConformEncodable(commonStrategies: [CodableCommonStrategy] = []) =
+    #externalMacro(module: "MacroPlugin", type: "ConformEncodable")

Sources/MetaCodable/MetaCodable.docc/MetaCodable.md

@@ -70,6 +70,8 @@ Supercharge `Swift`'s `Codable` implementations with macros.
 ### Macros
 
 - ``Codable(commonStrategies:)``
+- ``ConformDecodable(commonStrategies:)``
+- ``ConformEncodable(commonStrategies:)``
 - ``MemberInit()``
 
 ### Strategies

Sources/PluginCore/Attributes/Codable/Codable.swift

@@ -51,6 +51,8 @@ package struct Codable: PeerAttribute {
                 EnumDeclSyntax.self, ActorDeclSyntax.self,
                 ProtocolDeclSyntax.self
             )
+            cantBeCombined(with: ConformDecodable.self)
+            cantBeCombined(with: ConformEncodable.self)
             cantDuplicate()
         }
     }

Sources/PluginCore/Attributes/Codable/Decodable/AttributeExpander+Decodable.swift

@@ -0,0 +1,43 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+extension AttributeExpander {
+    /// Generates extension declarations for `Decodable` macro.
+    ///
+    /// From the variables registered by `Decodable` macro,
+    /// `Decodable` protocol conformance and `CodingKey` type
+    /// declarations are generated in separate extensions.
+    ///
+    /// - Parameters:
+    ///   - type: The type for which extensions provided.
+    ///   - protocols: The list of `Decodable` protocols to add
+    ///     conformances to. These will always be `Decodable`.
+    ///   - context: The context in which to perform the macro expansion.
+    ///
+    /// - Returns: The generated extension declarations.
+    func decodableExpansion(
+        for type: some TypeSyntaxProtocol,
+        to protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) -> [ExtensionDeclSyntax] {
+        let dProtocol = TypeCodingLocation.Method.decode().protocol
+        let decodable = variable.protocol(named: dProtocol, in: protocols)
+
+        var extensions = [
+            decoding(type: type, conformingTo: decodable, in: context),
+            codingKeys(for: type, confirmingTo: protocols, in: context),
+        ].compactMap { $0 }
+        for index in extensions.indices {
+            // attach available attributes from original declaration
+            // to generated expanded declaration
+            extensions[index].attributes = AttributeListSyntax {
+                for attr in options.availableAttributes {
+                    .attribute(attr)
+                }
+                extensions[index].attributes
+            }
+        }
+        return extensions
+    }
+}