Swift 4 KVO block crash: observed object deallocated while observer was still registered

Question

I started developing my app recently with iOS 11 as target version, because that was the default value. I have now lowered the version to 9.3, because of reasons.

The app is pure swift 4, using the new KVO block thing. I fixed the few compile-time errors I had with safeAreaInsets and whatnot, and the app built successfully. A quick job. Nice.

I tried running it on an iPhone 7 iOS 10.3.1 Simulator, and lord - it was a train wreck. I guess UITableViewAutomaticDimension wasn't really a thing back in the days.

Anyway, I have fixed most of the layout-issues, but now I'm stuck with a few hard crashes. Everywhere I've used this new KVO it crashes when I navigate back. My navigation-pushed ViewController is KVO-listening to a field inside an object it holds. When I pop the navigation, the viewController and the object is deallocated, in that order, and the app crashes, giving me this error:

*** Terminating app due to uncaught exception 'NSInternalInconsistencyException', reason: 'An instance 0x7fdf2e724250 of class MyProject.MyObject was deallocated while key value observers were still registered with it. Current observation info: <NSKeyValueObservationInfo 0x60800003fd80> (
<NSKeyValueObservance 0x610000050020: Observer: 0x61000006f140, Key path: isSelected, Options: <New: NO, Old: NO, Prior: NO> Context: 0x0, Property: 0x6180000595f0>
)'

As far as I can tell, it says that the observed object MyObject was deallocated while there was someone observing the variable isSelected.

This is the oberservation-code in MyViewController that observes MyObject.

var observations:[NSKeyValueObservation] = []
func someFunction() {
    observations.removeAll()
    let myObject = MyObject(/*init*/)
    self.myObject = myObject
    observations.append(myObject.observe(\.isSelected, changeHandler: { [weak self] (object, value) in
        //Do stuff
    }))
}

I was under the impression that this new magic KVO-block-style would solve world peace, but apparently that only applies to iOS 11.

Now, I have tried a few things, but I can't get it to not crash. It happens every single time, and I don't understand why.

Since the crash logs tells me that the observed object is being deallocated while an object is observing it, but I also know that the observing object is deallocated before the observed object, I have tried doing this in the observer:

//In MyViewController
deinit {
    observations.forEach({$0.invalidate()})
    observations.removeAll()
    print("Observers removed")
}

But this doesn't help. I have also done this:

//In MyObject
deinit{
    print("MyObject deinit")
}

And when I do the thing - I get the following output:

>Observers removed
>MyObject deinit
>WORLD WAR 5 STACK TRACE

I have also tried

//In MyViewController
deinit{
    self.myObject.removeObserver(self, forKeyPath: "isSelected")
}

But I get the output saying Can't remove because it is not registered as an observer. So I guess MyViewController isn't actually the observer that gets attached when using this new KVO.

Why didn't any of this work? Where and when do I have to remove the observers in < iOS11?

Answer 1

It looks like you're running into a bug that I reported about a year ago, but which unfortunately has received very little attention:

https://bugs.swift.org/browse/SR-5752

Since this bug hasn't bitten me in a while, I had hoped that it'd been fixed in the Swift overlay, but I just tried copying my code from the bug report into an iOS project and running it in the 10.3.1 simulator, and sure enough, the crash came back.

You can work around it like this:

deinit {
    for eachObservation in observations {
        if #available(/*whichever version of iOS fixes this*/) { /* do nothing */ } else {
            self.removeObserver(eachObservation, forKeyPath: #keyPath(/*the key path*/))
        }
        eachObservation.invalidate()
    }

    observations.removeAll()
}

Make sure you only do this on iOS versions affected by the bug, because otherwise you'll remove an observation that's already been removed, and then that will probably crash. Isn't this fun?