Core Data and Swift 6 concurrency: returning an NSManagedObject

Question

Created Apr ’25

Replies 0

Boosts 0

Participants 1

We're in the process of migrating our app to the Swift 6 language mode. I have hit a road block that I cannot wrap my head around, and it concerns Core Data and how we work with NSManagedObject instances.

Greatly simplied, our Core Data stack looks like this:

class CoreDataStack {
    private let persistentContainer: NSPersistentContainer
    var viewContext: NSManagedObjectContext { persistentContainer.viewContext }
}

For accessing the database, we provide Controller classes such as e.g.

class PersonController {
    private let coreDataStack: CoreDataStack

    func fetchPerson(byName name: String) async throws -> Person? {
        try await coreDataStack.viewContext.perform {
            let fetchRequest = NSFetchRequest<Person>()
            fetchRequest.predicate = NSPredicate(format: "name == %@", name)
            return try fetchRequest.execute().first
        }
    }
}

Our view controllers use such controllers to fetch objects and populate their UI with it:

class MyViewController: UIViewController {
    private let chatController: PersonController
    private let ageLabel: UILabel

    func populateAgeLabel(name: String) {
        Task {
            let person = try? await chatController.fetchPerson(byName: name)
            ageLabel.text = "\(person?.age ?? 0)"
        }
    }
}

This works very well, and there are no concurrency problems since the managed objects are fetched from the view context and accessed only in the main thread.

When turning on Swift 6 language mode, however, the compiler complains about the line calling the controller method:

Non-sendable result type 'Person?' cannot be sent from nonisolated context in call to instance method 'fetchPerson(byName:)'

Ok, fair enough, NSManagedObject is not Sendable. No biggie, just add @MainActor to the controller method, so it can be called from view controllers which are also main actor. However, now the compiler shows the same error at the controller method calling viewContext.perform:

Non-sendable result type 'Person?' cannot be sent from nonisolated context in call to instance method 'perform(schedule:_:)'

And now I'm stumped. Does this mean NSManageObject instances cannot even be returned from calls to NSManagedObjectContext.perform? Ever? Even though in this case, @MainActor matches the context's actor isolation (since it's the view context)?

Of course, in this simple example the controller method could just return the age directly, and more complex scenarios could return Sendable data structures that are instantiated inside the perform closure. But is that really the only legal solution? That would mean a huge refactoring challenge for our app, since we use NSManageObject instances fetched from the view context everywhere. That's what the view context is for, right?

tl;dr: is it possible to return NSManagedObject instances fetched from the view context with Swift 6 strict concurrency enabled, and if so how?

Boost