Added protocol CodingKeyRepresentable

stdlib/public/core/Codable.swift

@@ -5510,15 +5510,74 @@ internal struct _DictionaryCodingKey: CodingKey {
   internal let stringValue: String
   internal let intValue: Int?
 
-  internal init?(stringValue: String) {
+  internal init(stringValue: String) {
     self.stringValue = stringValue
     self.intValue = Int(stringValue)
   }
 
-  internal init?(intValue: Int) {
+  internal init(intValue: Int) {
     self.stringValue = "\(intValue)"
     self.intValue = intValue
   }
+
+  fileprivate init(codingKey: CodingKey) {
+    self.stringValue = codingKey.stringValue
+    self.intValue = codingKey.intValue
+  }
+}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+public protocol CodingKeyRepresentable {
+  var codingKey: CodingKey { get }
+  init?<T: CodingKey>(codingKey: T)
+}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+extension RawRepresentable where Self: CodingKeyRepresentable, RawValue == String {
+  public var codingKey: CodingKey {
+    _DictionaryCodingKey(stringValue: rawValue)
+  }
+  public init?<T: CodingKey>(codingKey: T) {
+    self.init(rawValue: codingKey.stringValue)
+  }
+}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+extension RawRepresentable where Self: CodingKeyRepresentable, RawValue == Int {
+  public var codingKey: CodingKey {
+    _DictionaryCodingKey(intValue: rawValue)
+  }
+  public init?<T: CodingKey>(codingKey: T) {
+    if let intValue = codingKey.intValue {
+      self.init(rawValue: intValue)
+    } else {
+      return nil
+    }
+  }
+}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+extension Int: CodingKeyRepresentable {
+  public var codingKey: CodingKey {
+    _DictionaryCodingKey(intValue: self)
+  }
+  public init?<T: CodingKey>(codingKey: T) {
+    if let intValue = codingKey.intValue {
+      self = intValue
+    } else {
+      return nil
+    }
+  }
+}
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+extension String: CodingKeyRepresentable {
+  public var codingKey: CodingKey {
+    _DictionaryCodingKey(stringValue: self)
+  }
+  public init?<T: CodingKey>(codingKey: T) {
+    self = codingKey.stringValue
+  }
 }
 
 extension Dictionary: Encodable where Key: Encodable, Value: Encodable {
@@ -5537,16 +5596,25 @@ extension Dictionary: Encodable where Key: Encodable, Value: Encodable {
       // Since the keys are already Strings, we can use them as keys directly.
       var container = encoder.container(keyedBy: _DictionaryCodingKey.self)
       for (key, value) in self {
-        let codingKey = _DictionaryCodingKey(stringValue: key as! String)!
+        let codingKey = _DictionaryCodingKey(stringValue: key as! String)
         try container.encode(value, forKey: codingKey)
       }
     } else if Key.self == Int.self {
       // Since the keys are already Ints, we can use them as keys directly.
       var container = encoder.container(keyedBy: _DictionaryCodingKey.self)
       for (key, value) in self {
-        let codingKey = _DictionaryCodingKey(intValue: key as! Int)!
+        let codingKey = _DictionaryCodingKey(intValue: key as! Int)
         try container.encode(value, forKey: codingKey)
       }
+    } else if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *), Key.self is CodingKeyRepresentable.Type {
+      // Since the keys are CodingKeyRepresentable, we can use the `codingKey`
+      // to create `_DictionaryCodingKey` instances.
+      var container = encoder.container(keyedBy: _DictionaryCodingKey.self)
+      for (key, value) in self {
+        let codingKey = (key as! CodingKeyRepresentable).codingKey
+        let dictionaryCodingKey = _DictionaryCodingKey(codingKey: codingKey)
+        try container.encode(value, forKey: dictionaryCodingKey)
+      }
     } else {
       // Keys are Encodable but not Strings or Ints, so we cannot arbitrarily
       // convert to keys. We can encode as an array of alternating key-value
@@ -5601,6 +5669,25 @@ extension Dictionary: Decodable where Key: Decodable, Value: Decodable {
         let value = try container.decode(Value.self, forKey: key)
         self[key.intValue! as! Key] = value
       }
+    } else if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *), let codingKeyRepresentableType = Key.self as? CodingKeyRepresentable.Type {
+      // The keys are CodingKeyRepresentable, so we should be able to expect a keyed container.
+      let container = try decoder.container(keyedBy: _DictionaryCodingKey.self)
+      for dictionaryCodingKey in container.allKeys {
+        guard let key: Key = codingKeyRepresentableType.init(
+          codingKey: dictionaryCodingKey
+        ) as? Key else {
+          throw DecodingError.dataCorruptedError(
+            forKey: dictionaryCodingKey,
+            in: container,
+            debugDescription: "Could not convert key to type \(Key.self)"
+          )
+        }
+        let value: Value = try container.decode(
+          Value.self,
+          forKey: dictionaryCodingKey
+        )
+        self[key] = value
+      }
     } else {
       // We should have encoded as an array of alternating key-value pairs.
       var container = try decoder.unkeyedContainer()

test/stdlib/CodableTests.swift

@@ -76,14 +76,23 @@ func expectRoundTripEquality<T : Codable>(of value: T, encode: (T) throws -> Dat
     expectEqual(value, decoded, "\(#file):\(lineNumber): Decoded \(T.self) <\(debugDescription(decoded))> not equal to original <\(debugDescription(value))>")
 }
 
-func expectRoundTripEqualityThroughJSON<T : Codable>(for value: T, lineNumber: Int) where T : Equatable {
+func expectRoundTripEqualityThroughJSON<T : Codable>(for value: T, _ expectedJSON: String? = nil, lineNumber: Int) where T : Equatable {
     let inf = "INF", negInf = "-INF", nan = "NaN"
     let encode = { (_ value: T) throws -> Data in
         let encoder = JSONEncoder()
         encoder.nonConformingFloatEncodingStrategy = .convertToString(positiveInfinity: inf,
                                                                       negativeInfinity: negInf,
                                                                       nan: nan)
-        return try encoder.encode(value)
+        if #available(macOS 10.13, iOS 11.0, watchOS 4.0, tvOS 11.0, *) {
+            encoder.outputFormatting = .sortedKeys
+        }
+        let encoded = try encoder.encode(value)
+
+        if let expectedJSON = expectedJSON {
+            let stringValue = String(decoding: encoded, as: UTF8.self)
+            expectEqual(expectedJSON, stringValue, "\(#file):\(lineNumber): Encoded \(T.self) <\(stringValue)> not equal to expected <\(expectedJSON)>")
+        }
+        return encoded
     }
 
     let decode = { (_ type: T.Type, _ data: Data) throws -> T in
@@ -462,6 +471,58 @@ class TestCodable : TestCodableSuper {
         }
     }
 
+    func test_Dictionary_JSON() {
+        enum X: String, Codable { case a, b }
+        enum Y: String, Codable, CodingKeyRepresentable { case a, b }
+        enum Z: String, Codable, CodingKeyRepresentable {
+            case a
+            case b
+            init?<T: CodingKey>(codingKey: T) {
+                self.init(rawValue: codingKey.stringValue)
+            }
+            var codingKey: CodingKey {
+                GenericCodingKey(stringValue: self.rawValue)
+            }
+        }
+
+        enum U: Int, Codable { case a = 0, b}
+        enum V: Int, Codable, CodingKeyRepresentable { case a = 0, b }
+        enum W: Int, Codable, CodingKeyRepresentable {
+            case a = 0
+            case b
+            init?<T: CodingKey>(codingKey: T) {
+                self.init(rawValue: codingKey.intValue!)
+            }
+            var codingKey: CodingKey {
+                GenericCodingKey(intValue: self.rawValue)
+            }
+        }
+
+
+        struct GenericCodingKey: CodingKey {
+            var stringValue: String
+            var intValue: Int?
+
+            init(stringValue: String) {
+                self.stringValue = stringValue
+            }
+
+            init(intValue: Int) {
+                self.stringValue = "\(intValue)"
+                self.intValue = intValue
+            }
+        }
+
+        expectRoundTripEqualityThroughJSON(for: [X.a: true],             #"["a",true]"#,           lineNumber: #line)
+        expectRoundTripEqualityThroughJSON(for: [Y.a: true, Y.b: false], #"{"a":true,"b":false}"#, lineNumber: #line)
+        expectRoundTripEqualityThroughJSON(for: [Z.a: true, Z.b: false], #"{"a":true,"b":false}"#, lineNumber: #line)
+
+        expectRoundTripEqualityThroughJSON(for: [U.a: true],             #"[0,true]"#,             lineNumber: #line)
+        expectRoundTripEqualityThroughJSON(for: [V.a: true, V.b: false], #"{"0":true,"1":false}"#, lineNumber: #line)
+        expectRoundTripEqualityThroughJSON(for: [W.a: true, W.b: false], #"{"0":true,"1":false}"#, lineNumber: #line)
+    }
+
+
     // MARK: - IndexPath
     lazy var indexPathValues: [Int : IndexPath] = [
         #line : IndexPath(), // empty
@@ -891,6 +952,7 @@ var tests = [
     "test_DateComponents_Plist" : TestCodable.test_DateComponents_Plist,
     "test_Decimal_JSON" : TestCodable.test_Decimal_JSON,
     "test_Decimal_Plist" : TestCodable.test_Decimal_Plist,
+    "test_Dictionary_JSON": TestCodable.test_Dictionary_JSON,
     "test_IndexPath_JSON" : TestCodable.test_IndexPath_JSON,
     "test_IndexPath_Plist" : TestCodable.test_IndexPath_Plist,
     "test_IndexSet_JSON" : TestCodable.test_IndexSet_JSON,