Why does a ReactiveSwift MutableProperty package in a property cause a leak?

Question

Here the Swift class that uses ReactiveSwift wraps MutablePropertyin Propertyand adds a subscription to Propertyin ScopedDisposable:

class Leaker {
    let mutableProperty = MutableProperty<Int>(0)

    var wrapperProperty: Property<Int> {
        return Property(self.mutableProperty)
    }

    private var disposable: ScopedDisposable<AnyDisposable>?

    init() {
        let disposable = CompositeDisposable()

        disposable += self.wrapperProperty.producer
            .startWithValues { value in
                print("\(value)")
            }

        self.disposable = ScopedDisposable(disposable)
    }
}

If I give another class a type property Leaker?and then set it with self.leaker = Leaker(), this creates a leak. Creates a leak, I mean that it installs the Leaks tool, showing a leaked object with a label Malloc 32 Bytes, with a stack trace that includes the Leaker.init()call Leaker.wrapperProperty.getter.

Why is this leak? It’s hard for me to understand what exactly makes the memory allocated here never be released.

Some other facts that may be helpful:

• This is not a leak if I sign up MutablePropertydirectly
• , MutableProperty
• , Leaker, . let _ = Leaker()

Answer 1

, . Leaker :

final class OtherClass {
  let leaker: Leaker?

  init() {
    self.leaker = Leaker()
  }
}

var otherClass: OtherClass? = OtherClass()

var mutablePropertyCompleted = false
otherClass!.leaker!.mutableProperty.producer.startWithCompleted {
  mutablePropertyCompleted = true
}

var wrappedPropertyCompleted = false
otherClass!.leaker!.wrapperProperty.producer.startWithCompleted {
  wrappedPropertyCompleted = true
}

otherClass = nil

if(!mutablePropertyCompleted) {
  print("LEAK")
}

if(!wrappedPropertyCompleted) {
  print("LEAK")
}

, MutableProperty completed deinit, , .

, , , .

, , , , , , , ?

, , , ReactiveSwift, , ( ReactiveSwift , Jjoelson )