[Macros] Implement own JSON encoder/decoder

Inspired by swift-foundation's JSONEncoder/JSONDecoder. But basically a
re-implementation of Encoder / Decoder.

(cherry picked from commit 61c7338)

Author: rintaro

Sources/SwiftCompilerPlugin/CompilerPlugin.swift

@@ -185,7 +185,9 @@ internal struct PluginHostConnection: MessageConnection {
 
   func sendMessage<TX: Encodable>(_ message: TX) throws {
     // Encode the message as JSON.
-    let payload = try JSONEncoder().encode(message)
+    let payload = try PluginMessageJSON.encode(message).withUnsafeBufferPointer { buffer in
+      Data(buffer: buffer)
+    }
 
     // Write the header (a 64-bit length field in little endian byte order).
     var count = UInt64(payload.count).littleEndian
@@ -226,7 +228,9 @@ internal struct PluginHostConnection: MessageConnection {
     }
 
     // Decode and return the message.
-    return try JSONDecoder().decode(RX.self, from: payload)
+    return try payload.withUnsafeBytes { buffer in
+      return try PluginMessageJSON.decode(RX.self, from:  buffer.bindMemory(to: UInt8.self))
+    }
   }
 
   enum PluginMessageError: Swift.Error {

Sources/SwiftCompilerPluginMessageHandling/JSON/CodingUtilities.swift

@@ -0,0 +1,97 @@
+
+//===----------------------------------------------------------------------===//
+// Coding Path Node
+//===----------------------------------------------------------------------===//
+
+// This construction allows overall fewer and smaller allocations as the coding path is modified.
+internal enum _CodingPathNode {
+  case root
+  indirect case node(CodingKey, _CodingPathNode)
+  indirect case indexNode(Int, _CodingPathNode)
+
+  var path : [any CodingKey] {
+    switch self {
+    case .root:
+      return []
+    case let .node(key, parent):
+      return parent.path + [key]
+    case let .indexNode(index, parent):
+      return parent.path + [_CodingKey(index: index)]
+    }
+  }
+
+  @inline(__always)
+  func appending(_ key: __owned (some CodingKey)?) -> _CodingPathNode {
+    if let key {
+      return .node(key, self)
+    } else {
+      return self
+    }
+  }
+
+  @inline(__always)
+  func path(byAppending key: __owned (some CodingKey)?) -> [CodingKey] {
+    if let key {
+      return self.path + [key]
+    }
+    return self.path
+  }
+
+  // Specializations for indexes, commonly used by unkeyed containers.
+  @inline(__always)
+  func appending(index: __owned Int) -> _CodingPathNode {
+    .indexNode(index, self)
+  }
+
+  func path(byAppendingIndex index: __owned Int) -> [CodingKey] {
+    self.path + [_CodingKey(index: index)]
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// Shared Key Type
+//===----------------------------------------------------------------------===//
+
+internal enum _CodingKey : CodingKey {
+  case string(String)
+  case int(Int)
+  case index(Int)
+
+  @inline(__always)
+  public init?(stringValue: String) {
+    self = .string(stringValue)
+  }
+
+  @inline(__always)
+  public init?(intValue: Int) {
+    self = .int(intValue)
+  }
+
+  @inline(__always)
+  internal init(index: Int) {
+    self = .index(index)
+  }
+
+  var stringValue: String {
+    switch self {
+    case let .string(str): return str
+    case let .int(int): return "\(int)"
+    case let .index(index): return "Index \(index)"
+    }
+  }
+
+  var intValue: Int? {
+    switch self {
+    case .string: return nil
+    case let .int(int): return int
+    case let .index(index): return index
+    }
+  }
+}
+
+struct JSONError: Error {
+  var message: String
+  init(message: String = "err") {
+    self.message = message
+  }
+}