Fix Swift mapping of ints within unions (#47)

This fixes an issue where a union with an int member cannot decode
any value that is out of the Int8 bounds.

Also: make SingleValueDecodingContainer throw `typeMismatch` errors
when the expected type doesn't match.

Author: bioball

Sources/PklSwift/Decoder/PklSingleValueDecodingContainer.swift

@@ -37,47 +37,55 @@ class PklSingleValueDecodingContainer: SingleValueDecodingContainer {
         switch self.value {
         case .bool(let value): return value
         default:
-            throw DecodingError.dataCorrupted(
+            throw DecodingError.typeMismatch(
+                Bool.self,
                 .init(
                     codingPath: self.codingPath,
                     debugDescription: "Expected a boolean, but got \(self.value.debugDataTypeDescription)"
-                ))
+                )
+            )
         }
     }
 
     func decode(_: String.Type) throws -> String {
         switch self.value {
         case .string(let value): return value
         default:
-            throw DecodingError.dataCorrupted(
+            throw DecodingError.typeMismatch(
+                String.self,
                 .init(
                     codingPath: self.codingPath,
                     debugDescription: "Expected a string, but got \(self.value.debugDataTypeDescription)"
-                ))
+                )
+            )
         }
     }
 
     func decode(_: Double.Type) throws -> Double {
         switch self.value {
         case .float(let value): return Double(value)
         default:
-            throw DecodingError.dataCorrupted(
+            throw DecodingError.typeMismatch(
+                Double.self,
                 .init(
                     codingPath: self.codingPath,
                     debugDescription: "Expected a float, but got \(self.value.debugDataTypeDescription)"
-                ))
+                )
+            )
         }
     }
 
     func decode(_: Float.Type) throws -> Float {
         switch self.value {
         case .float(let value): return Float(value)
         default:
-            throw DecodingError.dataCorrupted(
+            throw DecodingError.typeMismatch(
+                Float.self,
                 .init(
                     codingPath: self.codingPath,
                     debugDescription: "Expected a float, but got \(self.value.debugDataTypeDescription)"
-                ))
+                )
+            )
         }
     }
 
@@ -124,7 +132,7 @@ class PklSingleValueDecodingContainer: SingleValueDecodingContainer {
     func decode<T>(_ type: T.Type) throws -> T where T: Decodable {
         if type == PklAny.self {
             guard let result = try _PklDecoder.decodePolymorphic(value, codingPath: codingPath) else {
-                throw DecodingError.dataCorrupted(.init(codingPath: self.codingPath, debugDescription: "Tried to decode but got nil"))
+                throw DecodingError.typeMismatch(T.self, .init(codingPath: self.codingPath, debugDescription: "Tried to decode but got nil"))
             }
             return result as! T
         }
@@ -135,13 +143,25 @@ class PklSingleValueDecodingContainer: SingleValueDecodingContainer {
 
     private func decodeBinaryInteger<T>() throws -> T where T: BinaryInteger {
         switch self.value {
-        case .int(let value): return T(value)
+        case .int(let value):
+            guard let result = T(exactly: value) else {
+                throw DecodingError.typeMismatch(
+                    T.self,
+                    .init(
+                        codingPath: self.codingPath,
+                        debugDescription: "Cannot fit \(value) into \(String(describing: T.self))"
+                    )
+                )
+            }
+            return result
         default:
-            throw DecodingError.dataCorrupted(
+            throw DecodingError.typeMismatch(
+                T.self,
                 .init(
                     codingPath: self.codingPath,
                     debugDescription: "Expected an int, but got \(self.value.debugDataTypeDescription)"
-                ))
+                )
+            )
         }
     }
 }

Tests/PklSwiftTests/Decoder/PklDecoderTest.swift

@@ -43,6 +43,11 @@ final class PklDecoderTests: XCTestCase {
         XCTAssertEqual(value, 42)
     }
 
+    func testDecodeInt8Overflow() throws {
+        let bytes: [UInt8] = [0xD2, 0xFF, 0x00, 0x00, 0x00]
+        XCTAssertThrowsError(try PklDecoder.decode(Int8.self, from: bytes), "Cannot fit -16777216 into Int8")
+    }
+
     func testDecodeString() throws {
         let bytes: [UInt8] = [
             0xD9, 0x27, 0x74, 0x68, 0x65, 0x20, 0x71, 0x75, 0x69, 0x63, 0x6B, 0x20, 0x66, 0x6F, 0x78,

Tests/PklSwiftTests/Fixtures/Generated/UnionTypes.pkl.swift

@@ -7,15 +7,19 @@ public protocol UnionTypes_Animal: PklRegisteredType, DynamicallyEquatable, Hash
     var name: String { get }
 }
 
+public protocol UnionTypes_Shape: PklRegisteredType, DynamicallyEquatable, Hashable {
+}
+
 extension UnionTypes {
     public enum Fruit: Decodable, Hashable {
         case banana(Banana)
         case grape(Grape)
         case apple(Apple)
 
         public init(from decoder: Decoder) throws {
-            let decoded = try decoder.singleValueContainer().decode(PklSwift.PklAny.self).value
-            switch decoded?.base {
+            let container = try decoder.singleValueContainer()
+            let value = try container.decode(PklSwift.PklAny.self).value
+            switch value?.base {
             case let decoded as Banana:
                 self = Fruit.banana(decoded)
             case let decoded as Grape:
@@ -27,7 +31,7 @@ extension UnionTypes {
                     Fruit.self,
                     .init(
                         codingPath: decoder.codingPath,
-                        debugDescription: "Expected type Fruit, but got \(String(describing: decoded))"
+                        debugDescription: "Expected type Fruit, but got \(String(describing: value))"
                     )
                 )
             }
@@ -46,8 +50,9 @@ extension UnionTypes {
         case donkey(Donkey)
 
         public init(from decoder: Decoder) throws {
-            let decoded = try decoder.singleValueContainer().decode(PklSwift.PklAny.self).value
-            switch decoded?.base {
+            let container = try decoder.singleValueContainer()
+            let value = try container.decode(PklSwift.PklAny.self).value
+            switch value?.base {
             case let decoded as Zebra:
                 self = ZebraOrDonkey.zebra(decoded)
             case let decoded as Donkey:
@@ -57,7 +62,7 @@ extension UnionTypes {
                     ZebraOrDonkey.self,
                     .init(
                         codingPath: decoder.codingPath,
-                        debugDescription: "Expected type ZebraOrDonkey, but got \(String(describing: decoded))"
+                        debugDescription: "Expected type ZebraOrDonkey, but got \(String(describing: value))"
                     )
                 )
             }
@@ -80,8 +85,9 @@ extension UnionTypes {
         }
 
         public init(from decoder: Decoder) throws {
-            let decoded = try decoder.singleValueContainer().decode(PklSwift.PklAny.self).value
-            switch decoded?.base {
+            let container = try decoder.singleValueContainer()
+            let value = try container.decode(PklSwift.PklAny.self).value
+            switch value?.base {
             case let decoded as any Animal:
                 self = AnimalOrString.animal(decoded)
             case let decoded as String:
@@ -91,7 +97,7 @@ extension UnionTypes {
                     AnimalOrString.self,
                     .init(
                         codingPath: decoder.codingPath,
-                        debugDescription: "Expected type AnimalOrString, but got \(String(describing: decoded))"
+                        debugDescription: "Expected type AnimalOrString, but got \(String(describing: value))"
                     )
                 )
             }
@@ -111,29 +117,108 @@ extension UnionTypes {
         case int(Int)
         case float64(Float64)
 
+        private static func decodeNumeric(from decoder: Decoder, _ container: any SingleValueDecodingContainer) -> IntOrFloat? {
+            return (try? .int(container.decode(Int.self)))
+                ?? (try? .float64(container.decode(Float64.self)))
+        }
+
+        public init(from decoder: Decoder) throws {
+            let container = try decoder.singleValueContainer()
+            let decoded = IntOrFloat.decodeNumeric(from: decoder, container)
+            if decoded != nil {
+                self = decoded!
+                return
+            }
+            let value = try container.decode(PklSwift.PklAny.self).value
+            throw DecodingError.typeMismatch(
+                IntOrFloat.self,
+                .init(
+                    codingPath: decoder.codingPath,
+                    debugDescription: "Expected type IntOrFloat, but got \(String(describing: value))"
+                )
+            )
+        }
+    }
+
+    public enum Environment: String, CaseIterable, CodingKeyRepresentable, Decodable, Hashable {
+        case dev = "dev"
+        case prod = "prod"
+        case qa = "qa"
+    }
+
+    public enum AnimalOrShape: Decodable, Hashable {
+        case animal(any Animal)
+        case shape(any Shape)
+
+        public static func ==(lhs: AnimalOrShape, rhs: AnimalOrShape) -> Bool {
+            switch (lhs, rhs) {
+            case let (.animal(a), .animal(b)):
+                return a.isDynamicallyEqual(to: b)
+            case let (.shape(a), .shape(b)):
+                return a.isDynamicallyEqual(to: b)
+            default:
+                return false
+            }
+        }
+
         public init(from decoder: Decoder) throws {
-            let decoded = try decoder.singleValueContainer().decode(PklSwift.PklAny.self).value
-            switch decoded?.base {
-            case let decoded as Int:
-                self = IntOrFloat.int(decoded)
-            case let decoded as Float64:
-                self = IntOrFloat.float64(decoded)
+            let container = try decoder.singleValueContainer()
+            let value = try container.decode(PklSwift.PklAny.self).value
+            switch value?.base {
+            case let decoded as any Animal:
+                self = AnimalOrShape.animal(decoded)
+            case let decoded as any Shape:
+                self = AnimalOrShape.shape(decoded)
             default:
                 throw DecodingError.typeMismatch(
-                    IntOrFloat.self,
+                    AnimalOrShape.self,
                     .init(
                         codingPath: decoder.codingPath,
-                        debugDescription: "Expected type IntOrFloat, but got \(String(describing: decoded))"
+                        debugDescription: "Expected type AnimalOrShape, but got \(String(describing: value))"
                     )
                 )
             }
         }
+
+        public func hash(into hasher: inout Hasher) {
+            switch self {
+            case let .animal(value):
+                hasher.combine(value)
+            case let .shape(value):
+                hasher.combine(value)
+            }
+        }
     }
 
-    public enum Environment: String, CaseIterable, CodingKeyRepresentable, Decodable, Hashable {
-        case dev = "dev"
-        case prod = "prod"
-        case qa = "qa"
+    public enum Numbers: Decodable, Hashable {
+        case int8(Int8)
+        case int16(Int16)
+        case int32(Int32)
+        case int(Int)
+
+        private static func decodeNumeric(from decoder: Decoder, _ container: any SingleValueDecodingContainer) -> Numbers? {
+            return (try? .int8(container.decode(Int8.self)))
+                ?? (try? .int16(container.decode(Int16.self)))
+                ?? (try? .int32(container.decode(Int32.self)))
+                ?? (try? .int(container.decode(Int.self)))
+        }
+
+        public init(from decoder: Decoder) throws {
+            let container = try decoder.singleValueContainer()
+            let decoded = Numbers.decodeNumeric(from: decoder, container)
+            if decoded != nil {
+                self = decoded!
+                return
+            }
+            let value = try container.decode(PklSwift.PklAny.self).value
+            throw DecodingError.typeMismatch(
+                Numbers.self,
+                .init(
+                    codingPath: decoder.codingPath,
+                    debugDescription: "Expected type Numbers, but got \(String(describing: value))"
+                )
+            )
+        }
     }
 
     public struct Module: PklRegisteredType, Decodable, Hashable {
@@ -169,6 +254,18 @@ extension UnionTypes {
 
         public var config: [Environment: String]
 
+        public var animalOrShape1: AnimalOrShape
+
+        public var animalOrShape2: AnimalOrShape
+
+        public var numbers1: Numbers
+
+        public var numbers2: Numbers
+
+        public var numbers3: Numbers
+
+        public var numbers4: Numbers
+
         public init(
             fruit1: Fruit,
             fruit2: Fruit,
@@ -184,7 +281,13 @@ extension UnionTypes {
             intOrFloat1: IntOrFloat,
             intOrFloat2: IntOrFloat,
             intOrFloat3: IntOrFloat,
-            config: [Environment: String]
+            config: [Environment: String],
+            animalOrShape1: AnimalOrShape,
+            animalOrShape2: AnimalOrShape,
+            numbers1: Numbers,
+            numbers2: Numbers,
+            numbers3: Numbers,
+            numbers4: Numbers
         ) {
             self.fruit1 = fruit1
             self.fruit2 = fruit2
@@ -201,6 +304,12 @@ extension UnionTypes {
             self.intOrFloat2 = intOrFloat2
             self.intOrFloat3 = intOrFloat3
             self.config = config
+            self.animalOrShape1 = animalOrShape1
+            self.animalOrShape2 = animalOrShape2
+            self.numbers1 = numbers1
+            self.numbers2 = numbers2
+            self.numbers3 = numbers3
+            self.numbers4 = numbers4
         }
     }
 
@@ -236,6 +345,18 @@ extension UnionTypes {
 
     public typealias Animal = UnionTypes_Animal
 
+    public typealias Shape = UnionTypes_Shape
+
+    public struct Square: Shape {
+        public static let registeredIdentifier: String = "UnionTypes#Square"
+
+        public var corners: Int
+
+        public init(corners: Int) {
+            self.corners = corners
+        }
+    }
+
     public struct Zebra: Animal {
         public static let registeredIdentifier: String = "UnionTypes#Zebra"