fix: fixed duplicate CodingKeys generated (#63)

Author: soumyamahunt

.vscode/settings.json

@@ -12,6 +12,7 @@
     },
     "swift.disableAutoResolve": true,
     "swift.swiftEnvironmentVariables": {
+        "METACODABLE_CI": "true",
         "SWIFT_SYNTAX_EXTENSION_MACRO_FIXED": "true"
     },
 }

MetaCodableMacro.podspec

@@ -29,8 +29,10 @@ Pod::Spec.new do |s|
     :execution_position => :before_compile
   }
 
-  s.user_target_xcconfig = {
+  xcconfig = {
     'OTHER_SWIFT_FLAGS' => "-Xfrontend -load-plugin-executable -Xfrontend #{plugin_path}",
     'METACODABLE_PLUGIN_BUILD_ENVIRONMENT' => 'METACODABLE_BEING_USED_FROM_COCOAPODS=true'
   }
+  s.user_target_xcconfig = xcconfig
+  s.pod_target_xcconfig = xcconfig
 end

Plugins/MetaProtocolCodable/Config.swift

@@ -23,16 +23,37 @@ struct Config {
         /// Files from the target which includes plugin and target dependencies
         /// present in current package manifest are checked.
         case direct
-        /// Represents to check all local targets.
+        /// Represents to check all local target dependencies.
         ///
         /// Files from the target which includes plugin and all targets
-        /// that are in the same project/package.
+        /// that are in the same project/package that are dependencies
+        /// of this target.
         case local
         /// Represents to check current target and all dependencies.
         ///
         /// Files from the target which includes plugin and all its
         /// dependencies are checked.
         case recursive
+
+        /// Creates a new instance by decoding from the given decoder.
+        ///
+        /// This initializer throws an error if reading from the decoder fails,
+        /// or if the data read is corrupted or otherwise invalid.
+        ///
+        /// - Parameter decoder: The decoder to read data from.
+        init(from decoder: Decoder) throws {
+            let rawValue = try String(from: decoder).lowercased()
+            guard let value = Self(rawValue: rawValue) else {
+                throw DecodingError.typeMismatch(
+                    Self.self,
+                    .init(
+                        codingPath: decoder.codingPath,
+                        debugDescription: "Data doesn't match any case"
+                    )
+                )
+            }
+            self = value
+        }
     }
 }
 
@@ -47,7 +68,7 @@ extension Config: Codable {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         self.scan =
             try container.decodeIfPresent(
-                ScanMode.self, forKey: .scan
+                ScanMode.self, forCaseInsensitiveKey: .scan
             ) ?? .target
     }
 
@@ -63,3 +84,45 @@ extension Config: Codable {
         #endif
     }
 }
+
+extension KeyedDecodingContainerProtocol {
+    /// Decodes a value of the given type for the given key case-insensitively,
+    /// if present.
+    ///
+    /// This method returns `nil` if the container does not have a value
+    /// associated with key case-insensitively, or if the value is null.
+    ///
+    /// - Parameters:
+    ///   - type: The type of value to decode.
+    ///   - key: The key that the decoded value is associated with.
+    ///
+    /// - Returns: A decoded value of the requested type, or `nil`
+    ///   if the `Decoder` does not have an entry associated with the given
+    ///   key, or if the value is a null value.
+    ///
+    /// - Throws: `DecodingError.typeMismatch` if the encountered
+    ///   encoded value is not convertible to the requested type or the key
+    ///   value matches multiple value case-insensitively.
+    func decodeIfPresent<T: Decodable>(
+        _ type: T.Type,
+        forCaseInsensitiveKey key: Key
+    ) throws -> T? {
+        let keys = self.allKeys.filter { eachKey in
+            eachKey.stringValue.lowercased() == key.stringValue.lowercased()
+        }
+
+        guard keys.count <= 1 else {
+            throw DecodingError.typeMismatch(
+                type,
+                .init(
+                    codingPath: codingPath,
+                    debugDescription: """
+                    Duplicate keys found, keys are case-insensitive.
+                    """
+                )
+            )
+        }
+
+        return try decodeIfPresent(type, forKey: keys.first ?? key)
+    }
+}

Plugins/MetaProtocolCodable/SourceTarget/MetaProtocolCodableSourceTarget.swift

@@ -70,7 +70,11 @@ extension Config {
             targets.append(target)
             allTargets = targets
         case .local:
-            allTargets = context.localTargets
+            allTargets = context.localTargets.filter { localTarget in
+                return target.recursiveTargets.contains { target in
+                    return target.moduleName == localTarget.moduleName
+                }
+            }
             modules = allTargets.lazy.map(\.moduleName).filter { module in
                 return module != target.moduleName
             }

Sources/HelperCoders/SequenceCoder/SequenceCoder.swift

@@ -11,7 +11,7 @@ import MetaCodable
 public struct SequenceCoder<Sequence, ElementHelper>: HelperCoder
 where
     Sequence: SequenceInitializable, ElementHelper: HelperCoder,
-    Sequence.Element == ElementHelper.Coded, Sequence: Equatable
+    Sequence.Element == ElementHelper.Coded
 {
     /// The ``/MetaCodable/HelperCoder`` for element.
     ///

Sources/HelperCoders/SequenceCoder/SequenceCoderConfiguration.swift

@@ -33,7 +33,7 @@ extension SequenceCoder {
         ///   - invalidDefault: The sequence to use in case of invalid data.
         ///   - emptyDefault: The sequence to use in case of empty data.
         public init(
-            lossy: Bool,
+            lossy: Bool = false,
             invalidDefault: Sequence? = nil, emptyDefault: Sequence? = nil
         ) {
             self.lossy = lossy
@@ -118,6 +118,27 @@ extension SequenceCoder.Configuration: OptionSet {
         )
     }
 
+    /// Returns a Boolean value indicating whether two values are equal.
+    ///
+    /// Equality is the inverse of inequality. For any values `a` and `b`,
+    /// `a == b` implies that `a != b` is `false`.
+    ///
+    /// - Parameters:
+    ///   - lhs: A value to compare.
+    ///   - rhs: Another value to compare.
+    ///
+    /// - Returns: Whether two values are equal.
+    private static func areEqual(_ lhs: Sequence?, _ rhs: Sequence?) -> Bool {
+        func `is`<T: Equatable>(value lhs: T, equalTo rhs: Any?) -> Bool {
+            return lhs == (rhs as? T)
+        }
+
+        guard
+            let lhs = lhs as? any Equatable
+        else { return false }
+        return `is`(value: lhs, equalTo: rhs)
+    }
+
     /// Updates current configuration in sync with provided configuration.
     ///
     /// The updated configuration has:
@@ -127,13 +148,13 @@ extension SequenceCoder.Configuration: OptionSet {
     /// - Parameter other: The new configuration.
     public mutating func formIntersection(_ other: Self) {
         let invalidDefault =
-            if other.invalidDefault == self.invalidDefault {
+            if Self.areEqual(other.invalidDefault, self.invalidDefault) {
                 self.invalidDefault
             } else {
                 nil as Sequence?
             }
         let emptyDefault =
-            if other.emptyDefault == self.emptyDefault {
+            if Self.areEqual(other.emptyDefault, self.emptyDefault) {
                 self.emptyDefault
             } else {
                 nil as Sequence?
@@ -171,7 +192,7 @@ extension SequenceCoder.Configuration: OptionSet {
     /// - Returns: True only if all the configuration data match.
     public static func == (lhs: Self, rhs: Self) -> Bool {
         return lhs.lossy == rhs.lossy
-            && lhs.invalidDefault == rhs.invalidDefault
-            && lhs.emptyDefault == rhs.emptyDefault
+            && areEqual(lhs.invalidDefault, rhs.invalidDefault)
+            && areEqual(lhs.emptyDefault, rhs.emptyDefault)
     }
 }

Sources/MetaCodable/Codable/IgnoreCodingInitialized.swift

@@ -64,6 +64,4 @@
 @attached(peer)
 @available(swift 5.9)
 public macro IgnoreCodingInitialized() =
-    #externalMacro(
-        module: "MacroPlugin", type: "IgnoreCodingInitialized"
-    )
+    #externalMacro(module: "MacroPlugin", type: "IgnoreCodingInitialized")

Sources/PluginCore/Attributes/CodedAs.swift

@@ -1,3 +1,4 @@
+@_implementationOnly import OrderedCollections
 @_implementationOnly import SwiftSyntax
 @_implementationOnly import SwiftSyntaxMacros
 
@@ -149,7 +150,7 @@ where Key == [String], Decl: AttributableDeclSyntax, Var: PropertyVariable {
             case let path = attr.providedPath,
             !path.isEmpty
         else { return self.updating(with: self.variable.any) }
-        let keys = codingKeys.add(keys: path, context: context)
+        let keys = OrderedSet(codingKeys.add(keys: path, context: context))
         let oldVar = self.variable
         let newVar = AliasedPropertyVariable(base: oldVar, additionalKeys: keys)
         return self.updating(with: newVar.any)

Sources/PluginCore/Variables/Property/AliasedPropertyVariable.swift

@@ -1,6 +1,7 @@
 @_implementationOnly import SwiftSyntax
 @_implementationOnly import SwiftSyntaxBuilder
 @_implementationOnly import SwiftSyntaxMacros
+@_implementationOnly import OrderedCollections
 
 /// A variable value containing additional `CodingKey`s for decoding.
 ///
@@ -18,7 +19,7 @@ where Wrapped: PropertyVariable {
     ///
     /// Represents all the additional `CodingKey`s that
     /// this variable could be encoded at.
-    let additionalKeys: [CodingKeysMap.Key]
+    let additionalKeys: OrderedSet<CodingKeysMap.Key>
 
     /// Provides the code syntax for decoding this variable
     /// at the provided location.
@@ -41,6 +42,9 @@ where Wrapped: PropertyVariable {
             case let .container(container, key, method) = location
         else { return base.decoding(in: context, from: location) }
         var allKeys = [key]
+        let additionalKeys = additionalKeys.filter { aKey in
+            return aKey.expr.trimmedDescription != key.trimmedDescription
+        }
         allKeys.append(contentsOf: additionalKeys.map(\.expr))
         let keysName: ExprSyntax = "\(CodingKeysMap.Key.name(for: name))Keys"
         let keyList = ArrayExprSyntax(expressions: allKeys)

Sources/PluginCore/Variables/Type/Data/CodingKeysMap/CodingKeysMap.swift

@@ -103,7 +103,7 @@ package final class CodingKeysMap {
         context: some MacroExpansionContext
     ) -> [Key] {
         guard !keys.isEmpty else { return [] }
-        let currentCases = data.values.map(\.name)
+        var currentCases: [String] { data.values.map(\.name) }
 
         if let field {
             let fieldIncluded = currentCases.contains(Key.name(for: field).text)