Complete strict concurrency checking enabled - Sendable classes with @Dependency

[niorko]

I am struggling with preparing my project for strict concurrency in Swift6.

The problem

To make SomeClassUsingDependency Sendable, I need to mark it as @unckecked Sendable, otherwise the testClient raises this warning:

Stored property '_testClient' of 'Sendable'-conforming class 'SomeClassUsingDependency' is mutable

Example:

import Dependencies


struct TestClient: Sendable {
    var doSomething: @Sendable () -> String
    var setSomething: @Sendable (String) -> Void
}

extension TestClient: DependencyKey {
    static var liveValue: TestClient {
        TestClient(
            doSomething: { "" },
            setSomething: { _ in }
        )
    }
}

extension DependencyValues {
    var testClient: TestClient {
        get { self[TestClient.self] }
        set { self[TestClient.self] = newValue }
    }
}

// MARK: - Class using Dependency

final class SomeClassUsingDependency: Sendable {
    
    @Dependency(\.testClient) var testClient  // ❗️Stored property '_testClient' of 'Sendable'-conforming class 'SomeClassUsingDependency' is mutable
}

The question

What would you suggest to be able to handle this warning properly?

Thank you.

[mbrandonw]

Hi @niorko, this is just the reality of property wrappers and concurrency. Every property wrapper is going to have this problem because they secretly create a var _ property, which of course does not play nicely with sendability. There was a proposal to allow for property wrappers with let, but it never went anywhere.

However, typically is very hard to make a class Sendable. Does your class truly have no mutable state whatsoever? If it does, then usually you have to provide your own locking under the hood and use @unchecked Sendable. And in that case then the warning goes away and you should make never mutate through _testClient.

Or alternatively you need to synchronize the entire class using a global actor, such as @MainActor.

[niorko]

So either:

• Transform it into an actor, which means all methods will be async from outside.
• Label it as @MainActor, though this might not be ideal for non-UI tasks.
• Declare it as Sendable, address any warnings, and mark it as @unchecked Sendable.
• Hope for the proposal to be accepted.

I think I will go with an actor, where the majority of methods are async, and @unchecked Sendable when there is a need for synchronicity.

[MontakOleg]

You can also work with Dependency struct directly, in that case you can avoid @uchecked Sendable:

final class SomeClassUsingDependency: Sendable {

    private let _testClient = Dependency(\.testClient)
    private var testClient: TestClient { _testClient.wrappedValue } // just for convenience
}

[qasim]

Naive followup: could this be accomplished with macros too? Where the dependency injection still looks like:

final class SomeClassUsingDependency: Sendable {
    @Dependency(\.testClient) private var testClient
}

but expands to a custom macro that mimics property wrapper behaviour but can enforce sendability.

[mbrandonw]

@qasim Yeah, that is theoretically possible, but I'm not sure all the type information can be inferred. You may need to do:

@Dependency(\.testClient) private var testClient: TetsClient

But besides that, it would also be unfortunate to incur the cost of macros for this library. Currently we do not use macros unless you opt into the DependencyMacros library.