Update to Swift 6.0 and fix Sendable conformance

- Update swift-tools-version to 6.0
- Make error enums fully Sendable compliant
- Use String types instead of Any/CodingKey in error cases

Author: AdamShare

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 5.7
+// swift-tools-version: 6.0
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -10,7 +10,7 @@ let package = Package(
         .library(
             name: "DictionaryEncoder",
             targets: ["DictionaryEncoder"]
-        ),
+        )
     ],
     dependencies: [
         // Dependencies declare other packages that this package depends on.

Sources/DictionaryEncoder/DictionaryDecoder.swift

@@ -18,24 +18,24 @@ import Combine
 import Foundation
 
 /// Errors from `DictionaryDecoder`
-public enum DictionaryDecoderError: LocalizedError {
+public enum DictionaryDecoderError: LocalizedError, Sendable {
     /// The dictionary value could not be decoded to the expected type.
-    case typeMismatch(expected: Any.Type, actual: Any, codingPath: [CodingKey])
+    case typeMismatch(expected: String, actual: String, codingPath: [String])
     /// A required key was not found in the dictionary.
-    case keyNotFound(CodingKey, codingPath: [CodingKey])
+    case keyNotFound(String, codingPath: [String])
     /// The value was null or missing when a non-optional was expected.
-    case valueNotFound(Any.Type, codingPath: [CodingKey])
+    case valueNotFound(String, codingPath: [String])
 
     public var errorDescription: String? {
         switch self {
         case let .typeMismatch(expected, actual, codingPath):
-            let path = codingPath.map(\.stringValue).joined(separator: ".")
-            return "Type mismatch at '\(path)': expected \(expected) but found \(type(of: actual))."
+            let path = codingPath.joined(separator: ".")
+            return "Type mismatch at '\(path)': expected \(expected) but found \(actual)."
         case let .keyNotFound(key, codingPath):
-            let path = codingPath.map(\.stringValue).joined(separator: ".")
-            return "Key '\(key.stringValue)' not found at '\(path)'."
+            let path = codingPath.joined(separator: ".")
+            return "Key '\(key)' not found at '\(path)'."
         case let .valueNotFound(type, codingPath):
-            let path = codingPath.map(\.stringValue).joined(separator: ".")
+            let path = codingPath.joined(separator: ".")
             return "Value of type \(type) not found at '\(path)'."
         }
     }

Sources/DictionaryEncoder/DictionaryEncoder.swift

@@ -18,14 +18,14 @@ import Combine
 import Foundation
 
 /// Errors from `DictionaryEncoder`
-public enum DictionaryEncoderError: LocalizedError {
+public enum DictionaryEncoderError: LocalizedError, Sendable {
     /// The type was not encoded to a keyed container so a dictionary could not be returned.
-    case notKeyedContainer(Any)
+    case notKeyedContainer(String)
 
     public var errorDescription: String? {
         switch self {
-        case let .notKeyedContainer(value):
-            return "\(value) does not encode to a keyed container."
+        case let .notKeyedContainer(typeDescription):
+            return "\(typeDescription) does not encode to a keyed container."
         }
     }
 }
@@ -65,9 +65,9 @@ public final class DictionaryEncoder: TopLevelEncoder {
         case .keyed:
             return container.dictionary
         case .singleValue:
-            throw DictionaryEncoderError.notKeyedContainer(value)
+            throw DictionaryEncoderError.notKeyedContainer(String(describing: type(of: value)))
         case .unkeyed:
-            throw DictionaryEncoderError.notKeyedContainer(value)
+            throw DictionaryEncoderError.notKeyedContainer(String(describing: type(of: value)))
         }
     }
 

Tests/DictionaryEncoderTests/DictionaryDecoderTests.swift

@@ -643,9 +643,9 @@ struct DictionaryDecoderTests {
     @Test("DictionaryDecoderError type mismatch description")
     func decoderErrorTypeMismatchDescription() throws {
         let error = DictionaryDecoderError.typeMismatch(
-            expected: String.self,
-            actual: 123,
-            codingPath: [AnyCodingKey("testKey")]
+            expected: "String",
+            actual: "Int",
+            codingPath: ["testKey"]
         )
         let description = error.errorDescription
         #expect(description != nil)
@@ -656,8 +656,8 @@ struct DictionaryDecoderTests {
     @Test("DictionaryDecoderError key not found description")
     func decoderErrorKeyNotFoundDescription() throws {
         let error = DictionaryDecoderError.keyNotFound(
-            AnyCodingKey("missingKey"),
-            codingPath: [AnyCodingKey("parent")]
+            "missingKey",
+            codingPath: ["parent"]
         )
         let description = error.errorDescription
         #expect(description != nil)
@@ -667,8 +667,8 @@ struct DictionaryDecoderTests {
     @Test("DictionaryDecoderError value not found description")
     func decoderErrorValueNotFoundDescription() throws {
         let error = DictionaryDecoderError.valueNotFound(
-            String.self,
-            codingPath: [AnyCodingKey("path")]
+            "String",
+            codingPath: ["path"]
         )
         let description = error.errorDescription
         #expect(description != nil)