fix: provided Inherits macro as workaround for class conformance error in SwiftUI (SwiftyLab#71)

soumyamahunt · web-flow · commit c27e3a80e4c0 · 2024-03-27T14:15:11.000+05:30
* fix: provided `Inherits` macro as workaround for class conformance error in SwiftUI

* chore: add words for spellcheck dictionary
diff --git a/.github/config/spellcheck-wordlist.txt b/.github/config/spellcheck-wordlist.txt
@@ -62,3 +62,5 @@ cocoapods
 DocumentationExtension
 mergeBehavior
 lowercasing
+SwiftData
+SwiftUI
diff --git a/Sources/MacroPlugin/Definitions.swift b/Sources/MacroPlugin/Definitions.swift
@@ -535,3 +535,40 @@ struct IgnoreCodingInitialized: PeerMacro {
         )
     }
 }
+
+/// Attribute type for `Inherits` macro-attribute.
+///
+/// This type can validate`Inherits` macro-attribute
+/// usage and extract data for `Codable` macro to
+/// generate implementation.
+///
+/// Attaching this macro to type allows indicating the generated
+/// `Codable` conformance whether a class already inheriting
+/// conformance from super class or not.
+struct Inherits: PeerMacro {
+    /// Provide metadata to `Codable` macro for final expansion
+    /// and verify proper usage of this macro.
+    ///
+    /// This macro doesn't perform any expansion rather `Codable` macro
+    /// uses when performing expansion.
+    ///
+    /// This macro verifies that macro usage condition is met by attached
+    /// declaration by using the `validate` implementation provided.
+    ///
+    /// - Parameters:
+    ///   - node: The attribute describing this macro.
+    ///   - declaration: The declaration this macro attribute is attached to.
+    ///   - context: The context in which to perform the macro expansion.
+    ///
+    /// - Returns: No declaration is returned, only attached declaration is
+    ///            analyzed.
+    static func expansion(
+        of node: AttributeSyntax,
+        providingPeersOf declaration: some DeclSyntaxProtocol,
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        return try PluginCore.Inherits.expansion(
+            of: node, providingPeersOf: declaration, in: context
+        )
+    }
+}
diff --git a/Sources/MacroPlugin/Plugin.swift b/Sources/MacroPlugin/Plugin.swift
@@ -24,5 +24,6 @@ struct MetaCodablePlugin: CompilerPlugin {
         MemberInit.self,
         CodingKeys.self,
         IgnoreCodingInitialized.self,
+        Inherits.self,
     ]
 }
diff --git a/Sources/MetaCodable/Codable/Codable.swift b/Sources/MetaCodable/Codable/Codable.swift
@@ -58,3 +58,36 @@
 @available(swift 5.9)
 public macro Codable() =
     #externalMacro(module: "MacroPlugin", type: "Codable")
+
+/// Indicates whether super class conforms to `Codable` or not.
+///
+/// By default, ``Codable()`` assumes class inherits `Decodable`
+/// or `Encodable` conformance if it doesn't receive protocol needs
+/// to be conformed from the compiler. Using this macro, it can be explicitly
+/// indicated that the class doesn't inherit conformance in such cases.
+///
+/// Following code indicates ``Codable()`` that `Item` class doesn't
+/// inherit conformance:
+/// ```swift
+/// @Codable
+/// @Model
+/// @Inherits(decodable: false, encodable: false)
+/// final class Item {
+///     @CodedAt("timestamp")
+///     var timestamp: Date? = nil
+///
+///     init() { }
+/// }
+/// ```
+///
+/// - Parameters:
+///   - decodable: Whether super class conforms to `Decodable`.
+///   - encodable: Whether super class conforms to `Encodable`.
+///
+/// - Note: This macro on its own only validates if attached declaration
+///   is a class declaration. ``Codable()`` macro uses this macro
+///   when generating final implementations.
+@attached(peer)
+@available(swift 5.9)
+public macro Inherits(decodable: Bool, encodable: Bool) =
+    #externalMacro(module: "MacroPlugin", type: "Inherits")
diff --git a/Sources/MetaCodable/MetaCodable.docc/Limitations.md b/Sources/MetaCodable/MetaCodable.docc/Limitations.md
@@ -76,3 +76,9 @@ Due to these limitations, `Encodable` conformance isn't generated, users has to
 ### Why MetaProtocolCodable plugin can't scan Xcode target dependencies?
 
 Currently Swift Package Manager always returns empty list for Xcode target dependencies as noted in [this bug](https://github.com/apple/swift-package-manager/issues/6003). Hence `MetaProtocolCodable` can currently only scan the files from the target or from the project including the target.
+
+### Why macro is breaking with SwiftData class?
+
+Currently during certain customization in SwiftUI, compiler is sending no protocol data to ``Codable()``. Due to this, ``Codable()`` tries to find `Codable` protocol implementation for the class. If no implementation found, ``Codable()`` assumes class inherits conformance from super class, and generates implementation accordingly causing issues like [#56](https://github.com/SwiftyLab/MetaCodable/issues/56).
+
+Until this is fixes from Swift compiler, ``Inherits(decodable:encodable:)`` macro can be used to indicate explicitly that class doesn't inherit `Codable` conformance.
diff --git a/Sources/MetaCodable/MetaCodable.docc/MetaCodable.md b/Sources/MetaCodable/MetaCodable.docc/MetaCodable.md
@@ -85,6 +85,7 @@ Supercharge `Swift`'s `Codable` implementations with macros.
 - ``IgnoreEncoding()``
 - ``CodingKeys(_:)``
 - ``IgnoreCodingInitialized()``
+- ``Inherits(decodable:encodable:)``
 
 ### Helpers
 
diff --git a/Sources/PluginCore/Attributes/Codable/Inherits.swift b/Sources/PluginCore/Attributes/Codable/Inherits.swift
@@ -0,0 +1,67 @@
+@_implementationOnly import SwiftSyntax
+
+/// Attribute type for `Inherits` macro-attribute.
+///
+/// This type can validate`Inherits` macro-attribute
+/// usage and extract data for `Codable` macro to
+/// generate implementation.
+///
+/// Attaching this macro to type allows indicating the generated
+/// `Codable` conformance whether a class already inheriting
+/// conformance from super class or not.
+package struct Inherits: PeerAttribute {
+    /// The node syntax provided
+    /// during initialization.
+    let node: AttributeSyntax
+
+    /// Whether super class conforms to `Decodable`.
+    ///
+    /// In case of no super class, this should be `false`.
+    var decodable: Bool {
+        return node.arguments?.as(LabeledExprListSyntax.self)?.first { expr in
+            expr.label?.tokenKind == .identifier("decodable")
+        }?.expression.as(BooleanLiteralExprSyntax.self)?.literal
+            .tokenKind == .keyword(.true)
+    }
+
+    /// Whether super class conforms to `Encodable`.
+    ///
+    /// In case of no super class, this should be `false`.
+    var encodable: Bool {
+        return node.arguments?.as(LabeledExprListSyntax.self)?.first { expr in
+            expr.label?.tokenKind == .identifier("encodable")
+        }?.expression.as(BooleanLiteralExprSyntax.self)?.literal
+            .tokenKind == .keyword(.true)
+    }
+
+    /// Creates a new instance with the provided node
+    ///
+    /// The initializer fails to create new instance if the name
+    /// of the provided node is different than this attribute.
+    ///
+    /// - Parameter node: The attribute syntax to create with.
+    /// - Returns: Newly created attribute instance.
+    init?(from node: AttributeSyntax) {
+        guard
+            node.attributeName.as(IdentifierTypeSyntax.self)!
+                .name.text == Self.name
+        else { return nil }
+        self.node = node
+    }
+
+    /// Builds diagnoser that can validate this macro
+    /// attached declaration.
+    ///
+    /// Builds diagnoser that validates attached declaration
+    /// is a class declaration, has `Codable` macro attached
+    /// and macro usage is not duplicated for the same declaration.
+    ///
+    /// - Returns: The built diagnoser instance.
+    func diagnoser() -> DiagnosticProducer {
+        return AggregatedDiagnosticProducer {
+            shouldNotDuplicate()
+            mustBeCombined(with: Codable.self)
+            expect(syntaxes: ClassDeclSyntax.self)
+        }
+    }
+}
diff --git a/Sources/PluginCore/Variables/Type/ClassVariable.swift b/Sources/PluginCore/Variables/Type/ClassVariable.swift
@@ -12,6 +12,21 @@ struct ClassVariable: TypeVariable, DeclaredVariable {
     /// The declaration used to create this variable.
     let decl: ClassDeclSyntax
 
+    /// The `Codable` protocol conformance inheritance data.
+    ///
+    /// Allows customizing generated implementation, based on whether
+    /// super class conforms to `Decodable` or `Encodable`.
+    var inherits: Inherits? {
+        for attribute in decl.attributes {
+            guard
+                case let .attribute(attribute) = attribute,
+                let attr = Inherits(from: attribute)
+            else { continue }
+            return attr
+        }
+        return nil
+    }
+
     /// Creates a new variable from declaration and expansion context.
     ///
     /// Uses the class declaration with member group to generate conformances.
@@ -110,28 +125,25 @@ struct ClassVariable: TypeVariable, DeclaredVariable {
         let newLocation: TypeCodingLocation
         let overridden: Bool
         var modifiers: DeclModifierListSyntax = [.init(name: "required")]
-        var code: CodeBlockItemListSyntax
-        #if swift(>=5.9.2)
+        let method = location.method
+        let conformance = TypeSyntax(stringLiteral: method.protocol)
+
         if location.conformance == nil, implementDecodable(location: location) {
-            let method = location.method
-            let conformance = TypeSyntax(stringLiteral: method.protocol)
             newLocation = .init(method: method, conformance: conformance)
-            overridden = true
-            code = "try super.\(method.name)(\(method.argLabel): \(method.arg))"
+            overridden = inherits?.decodable ?? true
         } else {
             newLocation = location
             overridden = false
-            code = ""
         }
-        #else
-        let conformance = TypeSyntax(stringLiteral: location.method.protocol)
-        newLocation = .init(method: location.method, conformance: conformance)
-        overridden = false
-        code = ""
-        #endif
+
         guard
             let generated = group.decoding(in: context, from: newLocation)
         else { return nil }
+        var code: CodeBlockItemListSyntax = if overridden {
+            "try super.\(method.name)(\(method.argLabel): \(method.arg))"
+        } else {
+            ""
+        }
         code.insert(contentsOf: generated.code, at: code.startIndex)
         modifiers.append(contentsOf: generated.modifiers)
         return .init(
@@ -157,32 +169,29 @@ struct ClassVariable: TypeVariable, DeclaredVariable {
     ) -> TypeGenerated? {
         let newLocation: TypeCodingLocation
         let overridden: Bool
-        var modifiers: DeclModifierListSyntax
-        var code: CodeBlockItemListSyntax
-        #if swift(>=5.9.2)
+        let method = location.method
+        let conformance = TypeSyntax(stringLiteral: method.protocol)
+
         if location.conformance == nil, implementEncodable(location: location) {
-            let method = location.method
-            let conformance = TypeSyntax(stringLiteral: method.protocol)
             newLocation = .init(method: method, conformance: conformance)
-            overridden = true
-            modifiers = [.init(name: "override")]
-            code = "try super.\(method.name)(\(method.argLabel): \(method.arg))"
+            overridden = inherits?.encodable ?? true
         } else {
             newLocation = location
             overridden = false
-            modifiers = []
-            code = ""
         }
-        #else
-        let conformance = TypeSyntax(stringLiteral: location.method.protocol)
-        newLocation = .init(method: location.method, conformance: conformance)
-        overridden = false
-        modifiers = []
-        code = ""
-        #endif
+
         guard
             let generated = group.encoding(in: context, to: newLocation)
         else { return nil }
+        var code: CodeBlockItemListSyntax
+        var modifiers: DeclModifierListSyntax
+        if overridden {
+            modifiers = [.init(name: "override")]
+            code = "try super.\(method.name)(\(method.argLabel): \(method.arg))"
+        } else {
+            modifiers = []
+            code = ""
+        }
         code.insert(contentsOf: generated.code, at: code.startIndex)
         modifiers.append(contentsOf: generated.modifiers)
         return .init(
diff --git a/Tests/MetaCodableTests/CodableInheritanceTests.swift b/Tests/MetaCodableTests/CodableInheritanceTests.swift
diff --git a/Tests/MetaCodableTests/CodableTests.swift b/Tests/MetaCodableTests/CodableTests.swift

Original file line number	Diff line number	Diff line change
`@@ -24,5 +24,6 @@ struct MetaCodablePlugin: CompilerPlugin {`
`24`	`24`	`MemberInit.self,`
`25`	`25`	`CodingKeys.self,`
`26`	`26`	`IgnoreCodingInitialized.self,`
	`27`	`+ Inherits.self,`
`27`	`28`	`]`
`28`	`29`	`}`