CR fix: make AttributeValue and Status use synthesized Codable implementation for swift >= 5.5

Gal Shelef · Gal Shelef · commit 27b6e74a068b · 2021-11-24T08:48:40.000+02:00
* choose a Codable synthesized vs. explicit extension for AttributeValue and Status based on swift version
* add tests for swift &gt;= 5.5 for forward compatibility of the explicit Codable implementation
diff --git a/Sources/OpenTelemetryApi/Common/AttributeValue.swift b/Sources/OpenTelemetryApi/Common/AttributeValue.swift
@@ -61,8 +61,9 @@ public enum AttributeValue: Equatable, CustomStringConvertible, Hashable {
     }
 }
 
-// this explicit Codable implementation for AttributeValue will probably be redundant with Swift 5.5
-extension AttributeValue: Codable {
+internal struct AttributeValueExplicitCodable : Codable {
+    let attributeValue: AttributeValue
+    
     enum CodingKeys: String, CodingKey {
         case string
         case bool
@@ -73,7 +74,15 @@ extension AttributeValue: Codable {
         case intArray
         case doubleArray
     }
-         
+    
+    enum AssociatedValueCodingKeys: String, CodingKey {
+        case associatedValue = "_0"
+    }
+    
+    internal init(attributeValue: AttributeValue) {
+        self.attributeValue = attributeValue
+    }
+    
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
             
@@ -86,45 +95,83 @@ extension AttributeValue: Codable {
 
         switch container.allKeys.first.unsafelyUnwrapped {
         case .string:
-            self = .string(try container.decode(String.self, forKey: .string))
+            let nestedContainer = try container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .string)
+            self.attributeValue = .string(try nestedContainer.decode(String.self, forKey: .associatedValue))
         case .bool:
-            self = .bool(try container.decode(Bool.self, forKey: .bool))
+            let nestedContainer = try container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .bool)
+            self.attributeValue = .bool(try nestedContainer.decode(Bool.self, forKey: .associatedValue))
         case .int:
-            self = .int(try container.decode(Int.self, forKey: .int))
+            let nestedContainer = try container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .int)
+            self.attributeValue = .int(try nestedContainer.decode(Int.self, forKey: .associatedValue))
         case .double:
-            self = .double(try container.decode(Double.self, forKey: .double))
+            let nestedContainer = try container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .double)
+            self.attributeValue = .double(try nestedContainer.decode(Double.self, forKey: .associatedValue))
         case .stringArray:
-            self = .stringArray(try container.decode([String].self, forKey: .stringArray))
+            let nestedContainer = try container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .stringArray)
+            self.attributeValue = .stringArray(try nestedContainer.decode([String].self, forKey: .associatedValue))
         case .boolArray:
-            self = .boolArray(try container.decode([Bool].self, forKey: .boolArray))
+            let nestedContainer = try container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .boolArray)
+            self.attributeValue = .boolArray(try nestedContainer.decode([Bool].self, forKey: .associatedValue))
         case .intArray:
-            self = .intArray(try container.decode([Int].self, forKey: .intArray))
+            let nestedContainer = try container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .intArray)
+            self.attributeValue = .intArray(try nestedContainer.decode([Int].self, forKey: .associatedValue))
         case .doubleArray:
-            self = .doubleArray(try container.decode([Double].self, forKey: .doubleArray))
+            let nestedContainer = try container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .doubleArray)
+            self.attributeValue = .doubleArray(try nestedContainer.decode([Double].self, forKey: .associatedValue))
         }
     }
 
     public func encode(to encoder: Encoder) throws {
         
         var container = encoder.container(keyedBy: CodingKeys.self)
         
-        switch self {
+        switch self.attributeValue {
         case .string(let value):
-            try container.encode(value, forKey: .string)
+            var nestedContainer = container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .string)
+            try nestedContainer.encode(value, forKey: .associatedValue)
         case .bool(let value):
-            try container.encode(value, forKey: .bool)
+            var nestedContainer = container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .bool)
+            try nestedContainer.encode(value, forKey: .associatedValue)
         case .int(let value):
-            try container.encode(value, forKey: .int)
+            var nestedContainer = container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .int)
+            try nestedContainer.encode(value, forKey: .associatedValue)
         case .double(let value):
-            try container.encode(value, forKey: .double)
+            var nestedContainer = container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .double)
+            try nestedContainer.encode(value, forKey: .associatedValue)
         case .stringArray(let value):
-            try container.encode(value, forKey: .stringArray)
+            var nestedContainer = container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .stringArray)
+            try nestedContainer.encode(value, forKey: .associatedValue)
         case .boolArray(let value):
-            try container.encode(value, forKey: .boolArray)
+            var nestedContainer = container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .boolArray)
+            try nestedContainer.encode(value, forKey: .associatedValue)
         case .intArray(let value):
-            try container.encode(value, forKey: .intArray)
+            var nestedContainer = container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .intArray)
+            try nestedContainer.encode(value, forKey: .associatedValue)
         case .doubleArray(let value):
-            try container.encode(value, forKey: .doubleArray)
+            var nestedContainer = container.nestedContainer(keyedBy: AssociatedValueCodingKeys.self, forKey: .doubleArray)
+            try nestedContainer.encode(value, forKey: .associatedValue)
         }
     }
 }
+
+#if swift(>=5.5)
+// swift 5.5 supports synthesizing Codable for enums with associated values
+// see https://github.com/apple/swift-evolution/blob/main/proposals/0295-codable-synthesis-for-enums-with-associated-values.md
+extension AttributeValue: Codable { }
+#else
+// for older swift versions use a forward compatible explicit Codable implementation
+extension AttributeValue: Codable {
+         
+    public init(from decoder: Decoder) throws {
+        let explicitDecoded = AttributeValueExplicitCodable(from: decoder)
+        
+        self = explicitDecoded.attributeValue
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        let explicitEncoded = AttributeValueExplicitCodable(attributeValue: self)
+        
+        explicitEncoded.encode(to: encoder)
+    }
+}
+#endif
diff --git a/Sources/OpenTelemetryApi/Trace/Status.swift b/Sources/OpenTelemetryApi/Trace/Status.swift
@@ -61,8 +61,9 @@ extension Status: CustomStringConvertible {
     }
 }
 
-// this explicit Codable implementation for Status will probably be redundant with Swift 5.5
-extension Status: Codable {
+internal struct StatusExplicitCodable : Codable {
+    let status: Status
+    
     enum CodingKeys: String, CodingKey {
         case ok
         case unset
@@ -77,6 +78,10 @@ extension Status: Codable {
         case description
     }
 
+    internal init(status: Status) {
+        self.status = status
+    }
+    
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
 
@@ -90,21 +95,21 @@ extension Status: Codable {
         switch container.allKeys.first.unsafelyUnwrapped {
         case .ok:
             _ = try container.nestedContainer(keyedBy: EmptyCodingKeys.self, forKey: .ok)
-            self = .ok
+            self.status = .ok
         case .unset:
             _ = try container.nestedContainer(keyedBy: EmptyCodingKeys.self, forKey: .unset)
-            self = .unset
+            self.status = .unset
         case .error:
             let nestedContainer = try container.nestedContainer(keyedBy: ErrorCodingKeys.self, forKey: .error)
-            self = .error(description: try nestedContainer.decode(String.self, forKey: .description))
+            self.status = .error(description: try nestedContainer.decode(String.self, forKey: .description))
         }
     }
 
     public func encode(to encoder: Encoder) throws {
 
         var container = encoder.container(keyedBy: CodingKeys.self)
 
-        switch self {
+        switch self.status {
         case .ok:
             _ = container.nestedContainer(keyedBy: EmptyCodingKeys.self, forKey: .ok)
         case .unset:
@@ -115,3 +120,25 @@ extension Status: Codable {
         }
     }
 }
+
+#if swift(>=5.5)
+// swift 5.5 supports synthesizing Codable for enums with associated values
+// see https://github.com/apple/swift-evolution/blob/main/proposals/0295-codable-synthesis-for-enums-with-associated-values.md
+extension Status: Codable { }
+#else
+// for older swift versions use a forward compatible explicit Codable implementation
+extension Status: Codable {
+
+    public init(from decoder: Decoder) throws {
+        let explicitDecoded = StatusExplicitCodable(from: decoder)
+        
+        self = explicitDecoded.status
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        let explicitEncoded = StatusExplicitCodable(status: self)
+        
+        explicitEncoded.encode(to: encoder)
+    }        
+}
+#endif
diff --git a/Tests/OpenTelemetryApiTests/Common/AttributeValueTests.swift b/Tests/OpenTelemetryApiTests/Common/AttributeValueTests.swift
@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import OpenTelemetryApi
+@testable import OpenTelemetryApi
 import XCTest
 
 class AttributeValueTest: XCTestCase {
@@ -149,6 +149,87 @@ class AttributeValueTest: XCTestCase {
         
         XCTAssertThrowsError(try decoder.decode(AttributeValue.self, from: "".data(using: .utf8)!))
         XCTAssertThrowsError(try decoder.decode(AttributeValue.self,
-                                                from: #"{"string":"MyStringAttributeValue", "int":1234}"#.data(using: .utf8)!))
+                                                from: #"{"string":{"_0":"MyStringAttributeValue"}, "int":{"_0":1234}}"#.data(using: .utf8)!))
     }
+    
+    #if swift(>=5.5)
+    // this test covers forward compatibility of the pre swift 5.5 encoding with post swift 5.5 decoding
+    func testAttributeValue_ExplicitCodableForwardCompatibility() throws {
+        
+        let encoder = JSONEncoder()
+        let decoder = JSONDecoder()
+        
+        var attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.string(""))
+        var decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+        
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.string("MyStringAttributeValue"))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.bool(true))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.int(123456))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.int(0))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.int(-123456))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.double(1.23456))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.double(0.0))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.double(-1.23456))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.stringArray([]))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.stringArray(["MyStringAttributeValue1", "MyStringAttributeValue2"]))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.boolArray([]))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.boolArray([true, false]))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.intArray([]))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.intArray([1, 3, 2]))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.doubleArray([]))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        attribute = AttributeValueExplicitCodable(attributeValue: AttributeValue.doubleArray([1.11, 0.01, -2.22]))
+        decodedAttribute = try decoder.decode(AttributeValue.self, from: try encoder.encode(attribute))
+        XCTAssertEqual(attribute.attributeValue, decodedAttribute)
+
+        XCTAssertThrowsError(try decoder.decode(AttributeValueExplicitCodable.self, from: "".data(using: .utf8)!))
+        XCTAssertThrowsError(try decoder.decode(AttributeValueExplicitCodable.self,
+                                                from: #"{"string":{"_0":"MyStringAttributeValue"}, "int":{"_0":1234}}"#.data(using: .utf8)!))
+    }
+    #endif
 }
diff --git a/Tests/OpenTelemetryApiTests/Trace/StatusTests.swift b/Tests/OpenTelemetryApiTests/Trace/StatusTests.swift
@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import OpenTelemetryApi
+@testable import OpenTelemetryApi
 import XCTest
 
 final class StatusTests: XCTestCase {
@@ -49,4 +49,32 @@ final class StatusTests: XCTestCase {
         XCTAssertThrowsError(try decoder.decode(Status.self,
                                                 from: #"{"error":{"description":"Error"}, "ok":{}}"#.data(using: .utf8)!))
     }
+    
+    #if swift(>=5.5)
+    // this test covers forward compatibility of the pre swift 5.5 encoding with post swift 5.5 decoding
+    func testStatusExplicitCodableForwardCompatibility() throws {
+        let encoder = JSONEncoder()
+        let decoder = JSONDecoder()
+        
+        var status = StatusExplicitCodable(status: Status.ok)
+        var decodedStatus = try decoder.decode(Status.self, from: try encoder.encode(status))
+        XCTAssertEqual(status.status, decodedStatus)
+        
+        status = StatusExplicitCodable(status: Status.unset)
+        decodedStatus = try decoder.decode(Status.self, from: try encoder.encode(status))
+        XCTAssertEqual(status.status, decodedStatus)
+        
+        status = StatusExplicitCodable(status: Status.error(description: "Error"))
+        decodedStatus = try decoder.decode(Status.self, from: try encoder.encode(status))
+        XCTAssertEqual(status.status, decodedStatus)
+        
+        status = StatusExplicitCodable(status: Status.error(description: ""))
+        decodedStatus = try decoder.decode(Status.self, from: try encoder.encode(status))
+        XCTAssertEqual(status.status, decodedStatus)
+        
+        XCTAssertThrowsError(try decoder.decode(StatusExplicitCodable.self, from: "".data(using: .utf8)!))
+        XCTAssertThrowsError(try decoder.decode(StatusExplicitCodable.self,
+                                                from: #"{"error":{"description":"Error"}, "ok":{}}"#.data(using: .utf8)!))
+    }
+    #endif
 }
