Crash with “suspend resume partial function”

We have been getting crash reports that include the phrase “suspend resume partial function” and which seem to come from our use of Swift Concurrency. An example stack trace is

Crashed: com.apple.root.user-initiated-qos.cooperative
EXC_BAD_ACCESS KERN_INVALID_ADDRESS 0x0000000cf855c2e0
0  libobjc.A.dylib                0x4174 objc_release + 16
1  libobjc.A.dylib                0x4174 objc_release_x0 + 16
2  libswiftCore.dylib             0x3ad2c8 swift_arrayDestroy + 124
3  libswiftCore.dylib             0x98f38 _ContiguousArrayStorage.__deallocating_deinit + 96
4  libswiftCore.dylib             0x3bd628 _swift_release_dealloc + 56
5  libswiftCore.dylib             0x3be44c bool swift::RefCounts<swift::RefCountBitsT<(swift::RefCountInlinedness)1> >::doDecrementSlow<(swift::PerformDeinit)1>(swift::RefCountBitsT<(swift::RefCountInlinedness)1>, unsigned int) + 132
6  MyAppName                      0x32e08c (3) suspend resume partial function for ProductUpdater.updateProducts() + 138 (Products.swift:138)
7  libswift_Concurrency.dylib     0x41948 swift::runJobInEstablishedExecutorContext(swift::Job*) + 416
8  libswift_Concurrency.dylib     0x42868 swift_job_runImpl(swift::Job*, swift::ExecutorRef) + 72
9  libdispatch.dylib              0x15944 _dispatch_root_queue_drain + 396
10 libdispatch.dylib              0x16158 _dispatch_worker_thread2 + 164
11 libsystem_pthread.dylib        0xda0 _pthread_wqthread + 228
12 libsystem_pthread.dylib        0xb7c start_wqthread + 8

Crashlytics seems to think that call 6 is the problem here, and it labels the crash as “(3) suspend resume partial function for ProductUpdater.updateProducts()”.

What does the phrase “suspend resume partial function” mean, and what does it indicate the program was doing that caused a problem? Here is a very rough sketch of the relevant part of the code:

struct Product: Codable, Equatable {
    var id: String
    var name: String
    var price: Int
}

struct ProductWrapper: Codable, Equatable {
    var metadata: String
    var products: [Product]

    static let none = ProductWrapper(metadata: "none", products: [])
}

class ProductUpdater {
    var userIsSignedIn: Bool = false
    var products: ProductWrapper = .none

    init() {
        Task {
            await updateProducts()
        }
    }

    private func updateProducts() async {
        // If there's no user signed in, we can't fetch the products.
        guard userIsSignedIn else {
            products = .none
            return
        }

        do {
            // This next line was line 138 in the original code:
            products = try await NetworkService.fetchProducts()
        } catch {
            print("Could not fetch products: \(error)")
        }
    }
}

Following the vague advice in this comment on a GitHub issue, I tried wrapping the assignment of products in a seemingly pointless continuation,

    private func updateProducts() async {
        // If there's no user signed in, we can't fetch the products.
        guard userIsSignedIn else {
            products = .none
            return
        }

        do {
            let updatedProducts = try await NetworkService.fetchProducts()
            await withCheckedContinuation { continuation in
                products = updatedProducts
                continuation.resume()
            }
        } catch {
            print("Could not fetch products: \(error)")
        }
    }

but this doesn’t seem to have solved the issue.

We use Xcode Cloud to produce our builds, and it is using Xcode 14.3.1 (Swift 5.8.1).

“suspend resume partial function” means that a Task was resumed after an await. A partial function is the portion of a function between two await calls (or the beginning or end of the function).

This crash is due to an over-release on an array. I would expect that you're accessing products (or mutating any part of ProductWrapper) on multiple threads.

I don't understand how this code compiles, though. init returns without initializing products, which is invalid. Maybe you're sliding past a compiler bug. You need to make sure that all properties are initialized before returning.

You're also modifying products via a Task on a random thread, which isn't valid.

I believe you want the following changes:

//  products needs an initial value
var products: ProductWrapper = ProductWrapper(metadata: "", products: [])

You probably want to make ProductUpdater MainActor:

@MainActor
class ProductUpdater {

This will ensure that your access and modifications of products are done atomically (it will push the Task in init onto the main actor as well). If you want it on another thread, you should almost certainly make it a regular actor rather than a class.

If that's still a problem, you'll need to add some kind of locking to products so it doesn't get accessed on multiple threads. I encourage turning on the thread sanitizer in your scheme (under Diagnostics) to see if there are additional places you have this problem.