Build coding paths lazily and read arrays in place

Sources/Decoder/DictionaryDecoder.swift

@@ -17,6 +17,11 @@ public final class DictionaryDecoder: Sendable {
         set { optionsMutex.withLock { $0.dataDecodingStrategy = newValue } }
     }
 
+    public var decimalDecodingStrategy: DictionaryDecimalDecodingStrategy {
+        get { optionsMutex.withLock { $0.decimalDecodingStrategy } }
+        set { optionsMutex.withLock { $0.decimalDecodingStrategy = newValue } }
+    }
+
     public var nonConformingFloatDecodingStrategy: DictionaryNonConformingFloatDecodingStrategy {
         get { optionsMutex.withLock { $0.nonConformingFloatDecodingStrategy } }
         set { optionsMutex.withLock { $0.nonConformingFloatDecodingStrategy = newValue } }
@@ -37,13 +42,15 @@ public final class DictionaryDecoder: Sendable {
     public init(
         dateDecodingStrategy: DictionaryDateDecodingStrategy = .deferredToDate,
         dataDecodingStrategy: DictionaryDataDecodingStrategy = .base64,
+        decimalDecodingStrategy: DictionaryDecimalDecodingStrategy = .deferredToDecimal,
         nonConformingFloatDecodingStrategy: DictionaryNonConformingFloatDecodingStrategy = .throw,
         keyDecodingStrategy: DictionaryKeyDecodingStrategy = .useDefaultKeys,
         userInfo: [CodingUserInfoKey: Sendable] = [:]
     ) {
         let options = DictionaryDecodingOptions(
             dateDecodingStrategy: dateDecodingStrategy,
             dataDecodingStrategy: dataDecodingStrategy,
+            decimalDecodingStrategy: decimalDecodingStrategy,
             nonConformingFloatDecodingStrategy: nonConformingFloatDecodingStrategy,
             keyDecodingStrategy: keyDecodingStrategy
         )
@@ -54,41 +61,33 @@ public final class DictionaryDecoder: Sendable {
 
     // MARK: - Instance Methods
 
-    public func decode<T: Decodable>(
-        _ type: T.Type = T.self,
-        from dictionary: [String: Any]
-    ) throws -> T {
+    private func rootDecoder(for dictionary: [String: Any]) -> DictionarySingleValueDecodingContainer {
         let options = optionsMutex.withLock { $0 }
 
-        let decoder = DictionarySingleValueDecodingContainer(
+        return DictionarySingleValueDecodingContainer(
             component: dictionary,
             options: options,
             userInfo: userInfo,
             codingPath: []
         )
+    }
 
-        return try T(from: decoder)
+    public func decode<T: Decodable>(
+        _ type: T.Type = T.self,
+        from dictionary: [String: Any]
+    ) throws -> T {
+        try T(from: rootDecoder(for: dictionary))
     }
 
     public func decode<T: Decodable>(from dictionary: [String: Any]) throws -> T {
         try decode(T.self, from: dictionary)
     }
 
-    @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
     public func decode<T: DecodableWithConfiguration>(
         _ type: T.Type = T.self,
         from dictionary: [String: Any],
         configuration: T.DecodingConfiguration
     ) throws -> T {
-        let options = optionsMutex.withLock { $0 }
-
-        let decoder = DictionarySingleValueDecodingContainer(
-            component: dictionary,
-            options: options,
-            userInfo: userInfo,
-            codingPath: []
-        )
-
-        return try T(from: decoder, configuration: configuration)
+        try T(from: rootDecoder(for: dictionary), configuration: configuration)
     }
 }

Sources/Decoder/DictionaryKeyedDecodingContainer.swift

@@ -1,6 +1,4 @@
-import Foundation
-
-internal class DictionaryKeyedDecodingContainer<Key: CodingKey>:
+internal final class DictionaryKeyedDecodingContainer<Key: CodingKey>:
     KeyedDecodingContainerProtocol,
     DictionaryComponentDecoder {
 
@@ -27,12 +25,12 @@ internal class DictionaryKeyedDecodingContainer<Key: CodingKey>:
         case .useDefaultKeys:
             self.components = components
 
-        case let.custom(closure):
-            let componentKeysAndValues = components.map { key, value in
-                (closure(codingPath.appending(AnyCodingKey(key))).stringValue, value)
-            }
+        case let .custom(closure):
+            let componentKeysAndValues = components
+                .sorted { $0.key < $1.key }
+                .map { key, value in (closure(codingPath.appending(AnyCodingKey(key))).stringValue, value) }
 
-            self.components = Dictionary(componentKeysAndValues) { $1 }
+            self.components = Dictionary(componentKeysAndValues) { first, _ in first }
         }
 
         self.options = options
@@ -42,6 +40,7 @@ internal class DictionaryKeyedDecodingContainer<Key: CodingKey>:
 
     // MARK: - Instance Methods
 
+    @inline(__always)
     private func component<T>(of type: T.Type = T.self, forKey key: Key) throws -> T {
         let anyComponent = components[key.stringValue]
 
@@ -57,6 +56,18 @@ internal class DictionaryKeyedDecodingContainer<Key: CodingKey>:
         return component
     }
 
+    // Unlike the default implementation of `decodeIfPresent`, looks the key up once rather than in `contains`,
+    // `decodeNil` and `decode`.
+    @inline(__always)
+    private func decodeIfPresent<T>(forKey key: Key, _ decode: (_ component: Any) throws -> T) rethrows -> T? {
+        guard let component = components[key.stringValue], !decodeNilComponent(from: component) else {
+            return nil
+        }
+
+        return try decode(component)
+    }
+
+    @inline(__always)
     private func superDecoder(forAnyKey key: CodingKey) throws -> Decoder {
         DictionarySingleValueDecodingContainer(
             component: components[key.stringValue],
@@ -69,7 +80,7 @@ internal class DictionaryKeyedDecodingContainer<Key: CodingKey>:
     // MARK: - KeyedDecodingContainerProtocol
 
     internal func contains(_ key: Key) -> Bool {
-        components.contains { $0.key == key.stringValue }
+        components.keys.contains(key.stringValue)
     }
 
     internal func decodeNil(forKey key: Key) throws -> Bool {
@@ -100,6 +111,13 @@ internal class DictionaryKeyedDecodingContainer<Key: CodingKey>:
         try decodeComponentValue(from: try component(forKey: key), at: codingPath.appending(key))
     }
 
+#if compiler(>=6.0)
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    internal func decode(_ type: Int128.Type, forKey key: Key) throws -> Int128 {
+        try decodeComponentValue(from: try component(forKey: key), at: codingPath.appending(key))
+    }
+#endif
+
     internal func decode(_ type: UInt.Type, forKey key: Key) throws -> UInt {
         try decodeComponentValue(from: try component(forKey: key), at: codingPath.appending(key))
     }
@@ -120,6 +138,13 @@ internal class DictionaryKeyedDecodingContainer<Key: CodingKey>:
         try decodeComponentValue(from: try component(forKey: key), at: codingPath.appending(key))
     }
 
+#if compiler(>=6.0)
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    internal func decode(_ type: UInt128.Type, forKey key: Key) throws -> UInt128 {
+        try decodeComponentValue(from: try component(forKey: key), at: codingPath.appending(key))
+    }
+#endif
+
     internal func decode(_ type: Double.Type, forKey key: Key) throws -> Double {
         try decodeComponentValue(from: try component(forKey: key), at: codingPath.appending(key))
     }
@@ -136,6 +161,114 @@ internal class DictionaryKeyedDecodingContainer<Key: CodingKey>:
         try decodeComponentValue(of: type, from: try component(forKey: key), at: codingPath.appending(key))
     }
 
+    internal func decodeIfPresent(_ type: Bool.Type, forKey key: Key) throws -> Bool? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: Int.Type, forKey key: Key) throws -> Int? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: Int8.Type, forKey key: Key) throws -> Int8? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: Int16.Type, forKey key: Key) throws -> Int16? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: Int32.Type, forKey key: Key) throws -> Int32? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: Int64.Type, forKey key: Key) throws -> Int64? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+#if compiler(>=6.0)
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    internal func decodeIfPresent(_ type: Int128.Type, forKey key: Key) throws -> Int128? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+#endif
+
+    internal func decodeIfPresent(_ type: UInt.Type, forKey key: Key) throws -> UInt? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: UInt8.Type, forKey key: Key) throws -> UInt8? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: UInt16.Type, forKey key: Key) throws -> UInt16? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: UInt32.Type, forKey key: Key) throws -> UInt32? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: UInt64.Type, forKey key: Key) throws -> UInt64? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+#if compiler(>=6.0)
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    internal func decodeIfPresent(_ type: UInt128.Type, forKey key: Key) throws -> UInt128? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+#endif
+
+    internal func decodeIfPresent(_ type: Double.Type, forKey key: Key) throws -> Double? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: Float.Type, forKey key: Key) throws -> Float? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent(_ type: String.Type, forKey key: Key) throws -> String? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(from: component, at: codingPath.appending(key))
+        }
+    }
+
+    internal func decodeIfPresent<T: Decodable>(_ type: T.Type, forKey key: Key) throws -> T? {
+        try decodeIfPresent(forKey: key) { component in
+            try decodeComponentValue(of: type, from: component, at: codingPath.appending(key))
+        }
+    }
+
     internal func nestedContainer<NestedKey: CodingKey>(
         keyedBy keyType: NestedKey.Type,
         forKey key: Key

Sources/Decoder/DictionarySingleValueDecodingContainer.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 internal final class DictionarySingleValueDecodingContainer:
     Decoder,
     SingleValueDecodingContainer,
@@ -56,6 +54,13 @@ internal final class DictionarySingleValueDecodingContainer:
         try decodeComponentValue(from: component, at: codingPath)
     }
 
+#if compiler(>=6.0)
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    internal func decode(_ type: Int128.Type) throws -> Int128 {
+        try decodeComponentValue(from: component, at: codingPath)
+    }
+#endif
+
     internal func decode(_ type: UInt.Type) throws -> UInt {
         try decodeComponentValue(from: component, at: codingPath)
     }
@@ -76,6 +81,13 @@ internal final class DictionarySingleValueDecodingContainer:
         try decodeComponentValue(from: component, at: codingPath)
     }
 
+#if compiler(>=6.0)
+    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
+    internal func decode(_ type: UInt128.Type) throws -> UInt128 {
+        try decodeComponentValue(from: component, at: codingPath)
+    }
+#endif
+
     internal func decode(_ type: Double.Type) throws -> Double {
         try decodeComponentValue(from: component, at: codingPath)
     }
@@ -110,7 +122,7 @@ internal final class DictionarySingleValueDecodingContainer:
     }
 
     internal func unkeyedContainer() throws -> UnkeyedDecodingContainer {
-        guard let components = component as? [Any?] else {
+        guard let components = DictionaryUnkeyedComponents(component) else {
             throw DecodingError.unkeyedContainerTypeMismatch(at: codingPath, component: component)
         }