Compiler Explorer

Source code

struct Foo: Encodable, MyEncodable {
  enum CodingKeys: CodingKey {
    case foo, bar
  }

var foo = 10
  var bar = "hello"

func encode(to encoder: some MyEncoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(foo, forKey: .foo)
    try container.encode(bar, forKey: .bar)
  }
}

func main1() {
  let foo = Foo()
  let encoder = _Encoder()
  try! foo.encode(to: encoder)
}

main1()

@usableFromInline
@inline(never)
func printField<T>(name: String, value: T) {
  print(name, value)
}

public protocol KeyedEncodingContainerProtocol {
  associatedtype Key: CodingKey
  mutating func encode<T: Encodable>(_ value: T, forKey key: Key) throws
}

public struct MyKeyedEncodingContainer<K: CodingKey> :
  KeyedEncodingContainerProtocol
{
  public typealias Key = K

/// The container for the concrete encoder.
  internal var _box: _KeyedEncodingContainerBase

/// Creates a new instance with the given container.
  ///
  /// - parameter container: The container to hold.
  public init<Container: KeyedEncodingContainerProtocol>(
    _ container: Container
  ) where Container.Key == Key {
    _box = _KeyedEncodingContainerBox(container)
  }

public mutating func encode<T: Encodable>(
    _ value: T,
    forKey key: Key
  ) throws {
    try _box.encode(value, forKey: key)
  }
}

internal class _KeyedEncodingContainerBase {
  internal init(){}

deinit {}

internal func encode<T: Encodable, K: CodingKey>(_ value: T, forKey key: K) throws {
    fatalError("_KeyedEncodingContainerBase cannot be used directly.")
  }
}

internal final class _KeyedEncodingContainerBox<
  Concrete: KeyedEncodingContainerProtocol
>: _KeyedEncodingContainerBase {
  typealias Key = Concrete.Key

internal var concrete: Concrete

internal init(_ container: Concrete) {
    concrete = container
  }

override internal func encode<T: Encodable, K: CodingKey>(
    _ value: T,
    forKey key: K
  ) throws {
    let key = unsafeBitCast(key, to: Key.self)
    try concrete.encode(value, forKey: key)
  }
}

protocol MyEncoder {
  func container<Key>(keyedBy type: Key.Type) -> MyKeyedEncodingContainer<Key>
}

protocol MyEncodable {
  func encode(to encoder: some MyEncoder) throws
}

@usableFromInline
final class _Encoder: MyEncoder {
  @inlinable
  init() {
  }

@inlinable
  func container<Key: CodingKey>(keyedBy _: Key.Type) -> MyKeyedEncodingContainer<Key> {
    MyKeyedEncodingContainer(_KeyedEncodingContainer<Key>())
  }
}

@usableFromInline
struct _KeyedEncodingContainer<Key: CodingKey>: KeyedEncodingContainerProtocol {
  @inlinable
  init(
  ) {
  }

@inlinable
  func encode<T>(_ value: T, forKey key: Key) throws where T: Encodable {
    let name = key.stringValue
    printField(name: name, value: value)
  }
}