Making CoreData singleton concurrency-safe

Consider this CoreData stack written for Swift 5.10

import CoreData

final class CoreDataStack {
    
    static let shared = CoreDataStack()
    
    private init() { }
    
    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "MyCoreData")
        
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
        return container
    }()
    
    lazy var mainContext: NSManagedObjectContext = {
        let context = persistentContainer.viewContext
        context.automaticallyMergesChangesFromParent = true
        return context
    }()
       
    lazy var backgroundContext: NSManagedObjectContext = {
        let context = persistentContainer.newBackgroundContext()
        return context
    }()

    func saveContext () {
        guard mainContext.hasChanges else { return }
        do {
            try mainContext.save()
            print("AppDelegate persistentContainer saved data")
        } catch {
            let nserror = error as NSError
            print("AppDelegate error savingContext \(nserror), \(nserror.userInfo)")
        }
    }
}

When checking against Swift 6 it gives the warning

Static property 'shared' is not concurrency-safe because it is either not conforming to 'Sendable' or isolated to a global actor; this is an error in Swift 6

How do you build a CoreData stack so that it is concurrency-safe?

Do I need to make it a Sendable Struct, or an unchecked Sendable class (with appropriate locks & queues? Or do I isolate it to a global actor (e.g. MainActor, and if so, how do I use the backgroundContext off the MainActor?

You can make some simple modifications to your class in order to make if properly Sendable without making it an actor, a struct, or isolating it to a global queue.

I'll start with the modified code:

// (1)
final class CoreDataStack: Sendable {
    
    static let shared = CoreDataStack()
    
    // (2)
    let persistentContainer: NSPersistentContainer
    
    // (3)
    private init() {
        self.persistentContainer = NSPersistentContainer(name: "MyCoreData")
        
        persistentContainer.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
    }
    
    // (4)
    var mainContext: NSManagedObjectContext {
        let context = persistentContainer.viewContext
        context.automaticallyMergesChangesFromParent = true
        return context
    }

    // (5)
    func newBackgroundContext() -> NSManagedObjectContext {
        let context = persistentContainer.newBackgroundContext()
        return context
    }

    // no changes to saveContext()
}

The changes are:

1. Explicitly make the class conform to Sendable. (You got the final part right, but you still need to tell the compiler that the class conforms to the protocol)
2. Make the NSPersistentContainer a stored, immutable property. NSPersistentContainer is Sendable, and there's no reason to make it a lazy var. Lazy vars seem to not work with Sendable anyway.
3. Move the initialization of the NSPersistentContainer to the init, since it's now a stored property. Again, there's no reason for it to be lazy, anyway, so initializing and loading the stores with the stack's initializer doesn't have any downsides I can see.
4. Make the mainContext a computed property. Since NSManagedObjectContext isn't Sendable, you wouldn't be able to have this as a stored property in a Sendable class, but since the viewContext can just be grabbed from the NSPersistentContainer every time you need it, a computed property is a perfectly good way to access it.
5. Do the same with the background context, but instead of a computed property, make it a function, since you're creating a new one every time you call this function, rather than accessing the same one.

That's all! Of course, it's really just the beginning, since you'll need to manage sendability elsewhere with the NSManagedObjectContexts, but this should get you started.