Is there a way to find Swift properties wrapped in property wrappers using reflection?

Question

I've been trying to get an @ObservedObject-like property wrapper (let's call it @Observed) working that would listen to Combine events published by @Published properties of a class adhering to the ObservableObject protocol. I want to do it this way because I want to hide all the sink handling behind a Swift package instead of managing it in the main code base. So I need a way to inspect from the new @Observed property wrapper into its held wrappedValue to see if any of its properties are @Published and hold sink references to them

Here's a bit of code to show you what I mean:

@propertyWrapper
struct Observed<T> where T : ObservableObject {
    var sinks = [AnyCancellable]()
    var wrappedValue: T
    
    init(wrappedValue: T) {
        self.wrappedValue = wrappedValue
        let mirror = Mirror(reflecting: wrappedValue)
        for case let (label?, value) in mirror.children {
            //if `value` is wrapped as an `@Published` property {
            //   grab sink to the property
            //}
        }
    }
}

EDIT: the ultimate purpose of this is to build SwiftUI-like Combine-reactive architecture that triggers off changes of an @Published property of a wrapped ObservableObject. Only instead of drawing to a window we do something like serialize the model instead. The thing that is hanging me up is how SwiftUI knows an update happened from a model of a child of a view in order for it to trigger a re-render. I figured if, at the root level, I could grab all the properties of children via reflection, I could sink them directly and trigger that kind of reactive architecture

Answer 1

You can't actually be caring about each property individually, if they're all getting erased to AnyCancellables. Instead, forward them through another object.

import Combine

public extension Published
where Value: ObservableObject, Value.ObjectWillChangePublisher == ObservableObjectPublisher {
  /// An `ObservableObject` that forwards its `objectWillChange` through a parent.
  @propertyWrapper struct Object {
    // MARK: propertyWrapper
    @available(*, unavailable, message: "The enclosing type is not an 'ObservableObject'.")
    public var wrappedValue: Value { get { fatalError() } set { } }

    public static subscript<Parent: ObservableObject>(
      _enclosingInstance parent: Parent,
      wrapped _: ReferenceWritableKeyPath<Parent, Value>,
      storage keyPath: ReferenceWritableKeyPath<Parent, Self>
    ) -> Value
    where Parent.ObjectWillChangePublisher == ObservableObjectPublisher {
      get { Self[_enclosingInstance: parent, storage: keyPath] }
      set { Self[_enclosingInstance: parent, storage: keyPath] = newValue }
    }

    // MARK: PublishedObject
    public var value: Value

    /// The subscription which forwards  `_wrappedValue`'s `objectWillChange` through a "parent".
    public var objectWillChangeSubscription: AnyCancellable!
  }
}

// MARK: - PublishedObject
extension Published.Object: PublishedObject {
  public var object: Value { value }
}

// MARK: - public
public extension Published.Object {
  init(wrappedValue: Value) {
    value = wrappedValue
  }
}

import Combine

public protocol PublishedObject {
  associatedtype Object: ObservableObject
  where Object.ObjectWillChangePublisher == ObservableObjectPublisher

  associatedtype WrappedValue

  init(wrappedValue: WrappedValue)
  var value: WrappedValue { get set }
  var object: Object { get }
  var objectWillChangeSubscription: AnyCancellable! { get set }
}

extension PublishedObject {
  static subscript<Parent: ObservableObject>(
    _enclosingInstance parent: Parent,
    storage keyPath: ReferenceWritableKeyPath<Parent, Self>
  ) -> WrappedValue
  where Parent.ObjectWillChangePublisher == ObservableObjectPublisher {
    get {
      @Computed(root: parent, keyPath: keyPath) var `self`

      // It's `nil` until a parent can be provided.
      if self.objectWillChangeSubscription == nil {
        self.setParent(parent)
      }

      return self.value
    }
    set {
      @Computed(root: parent, keyPath: keyPath) var `self`
      self.value = newValue
      self.setParent(parent)
      parent.objectWillChange.send()
    }
  }

  private mutating func setParent<Parent: ObservableObject>(_ parent: Parent)
  where Parent.ObjectWillChangePublisher == ObservableObjectPublisher {
    objectWillChangeSubscription = object.objectWillChange.subscribe(parent.objectWillChange)
  }
}

/// A workaround for limitations of Swift's computed properties.
///
/// Limitations of Swift's computed property accessors:
/// 1. They are not mutable.
/// 2. They cannot be referenced as closures.
@propertyWrapper public struct Computed<Value> {
  public typealias Get = () -> Value
  public typealias Set = (Value) -> Void

  public init(
    get: @escaping Get,
    set: @escaping Set
  ) {
    self.get = get
    self.set = set
  }

  public var get: Get
  public var set: Set

  public var wrappedValue: Value {
    get { get() }
    nonmutating set { set(newValue) }
  }

  public var projectedValue: Self {
    get { self }
    set { self = newValue }
  }
}

// MARK: - public
public extension Computed {
  /// Convert a `KeyPath` to a get/set accessor pair.
  init<Root>(
    root: Root,
    keyPath: ReferenceWritableKeyPath<Root, Value>
  ) {
    self.init(
      get: { root[keyPath: keyPath] },
      set: { root[keyPath: keyPath] = $0 }
    )
  }
}

import Combine

/// The simplest way to forward one `objectWillChange` through another
/// is to make `ObservableObjectPublisher` be a `Subject`,
/// so that `Publisher.subscribe` can be used with it.
extension ObservableObjectPublisher: Subject {
  public func send(subscription: any Subscription) {
    subscription.request(.unlimited)
  }

  public func send(_: Void) {
    send()
  }

  public func send(completion _: Subscribers.Completion<Never>) { }
}