@DependencyClient macro causing Int parameters to be changed to 0 when not in Swift 6 language mode

[jcmourey]

From slack:

I am completely mystified by this. I created the smallest possible app to exhibit the issue.

It's only broken when using async functions AND the @DependencyClient macro.

import Dependencies
import DependenciesMacros
import SwiftUI

// Using DependencyClient macro
@DependencyClient
struct Buggy {
    var syncWorks: (Int) -> Void
    var asyncBroken: (Int) async -> Void
}

extension Buggy: DependencyKey {
    static let liveValue =
        Self(
            syncWorks: { print("syncWorks:", $0) },
            asyncBroken: { print("asyncBroken:", $0) }
        )
}

// Not using DependencyClient macro
struct Works {
    var syncWorks: (Int) -> Void
    var asyncWorks: (Int) async -> Void
}

extension Works: DependencyKey {
    static let liveValue = Self(
        syncWorks: { print("syncWorks:", $0) },
        asyncWorks: { print("asyncWorks:", $0) }
    )
}

@main
struct testApp: App {
    var body: some Scene {
        WindowGroup {
            EmptyView()
                .task {
                    print("Using @DependencyClient:")
                    @Dependency(Buggy.self) var buggy
                    buggy.syncWorks(10) // prints 10
                    await buggy.asyncBroken(10) // prints 0
                    
                    print("\nNot using @DependencyClient:")
                    @Dependency(Works.self) var works
                    works.syncWorks(10) // prints 10
                    await works.asyncWorks(10) // prints 10
                }
        }
    }
}

Ilia found this gets fixed by using Swift 6 language mode.

[mbrandonw]

Hi @jcmourey, I am guessing you are using default main actor isolation and Swift 5 language mode (the defaults for new Xcode 26 projects)? Technically right now your code is invalid from a concurrency stand point, but the errors/warnings are being hidden from you because of Swift 5 mode. The print outs you are seeing are just the effect of undefined behavior due to using the concurrency tools incorrectly (sometimes Swift will just crash too).

You can either turn those errors/warnings on (either Swift 6 language mode or complete concurrency checking) to fix the problems, and then you will see that that the print outs are correct. Or you can turn off default main actor isolation to get the correct print outs.

And the problem you are seeing here is the same thing happening in this discussion #404, and is one of the many reasons why we recommend not using the default settings for new projects in Xcode 26.

[jcmourey]

Thanks, @mbrandonw. Adding back the Sendable conformances allows this code to build in Swift 6 with default main actor isolation turned off. And the code works correctly.

However, keeping that same new code, when I go back to Swift 5 mode with default main actor isolation, I'm still getting the same incorrect behavior.

I'm not using that mode anymore, but am I missing something? Seems like it should work in either mode, no?

import Dependencies
import DependenciesMacros
import SwiftUI

// Using DependencyClient macro
@DependencyClient
struct Buggy: Sendable {
    var syncWorks: @Sendable (Int) -> Void
    var asyncBroken: @Sendable (Int) async -> Void
}

extension Buggy: DependencyKey {
    static let liveValue =
        Self(
            syncWorks: { print("syncWorks:", $0) },
            asyncBroken: { print("asyncBroken:", $0) }
        )
}

// Not using DependencyClient macro
struct Works: Sendable {
    var syncWorks: @Sendable (Int) -> Void
    var asyncWorks: @Sendable (Int) async -> Void
}

extension Works: DependencyKey {
    static let liveValue = Self(
        syncWorks: { print("syncWorks:", $0) },
        asyncWorks: { print("asyncWorks:", $0) }
    )
}

@main
struct testApp: App {
    var body: some Scene {
        WindowGroup {
            EmptyView()
                .task {
                    print("Using @DependencyClient:")
                    @Dependency(Buggy.self) var buggy
                    buggy.syncWorks(10) // prints 10
                    await buggy.asyncBroken(10) // prints 0
                    
                    print("\nNot using @DependencyClient:")
                    @Dependency(Works.self) var works
                    works.syncWorks(10) // prints 10
                    await works.asyncWorks(10) // prints 10
                }
        }
    }
}

[mbrandonw]

Hi @jcmourey, for some reason turning on "complete" concurrency checking in Swift 5 mode also fixes the problem.

I don't have an explanation for you, but hope you can see that this is just a Swift bug and so I would recommend filing an issue on the Swift repo. There really isn't much we can do in the library to fix this.

[jcmourey]

Hi @mbrandonw. Thank you for having taken the time to answer me. This issue doesn't really affect me anymore since I only use the strictest concurrency settings now.

I am bit worried that it might discourage someone new to pointfree though, because all one needs to do is create a new XCode project with default options unchanged, follow the documentation to create the simplest dependency with a closure with an Int argument, write 100% concurrent-compliant code, and it just won't work. No errors, no warning, no crash.

It would be cool if the library could defensively protect against this by issuing a warning to change the default Xcode concurrency / language settings when using the DependencyClient macro, or if not technically feasible, at least document it prominently in the documentation for the macro.

What do you think?

[mbrandonw]

Hi @jcmourey, we will certainly update parts of the docs, but unfortunately 1) most people don't read the docs, and 2) we would need to mention this caveat in many, many places.

It would be cool if the library could defensively protect against this by issuing a warning to change the default Xcode concurrency / language settings when using the DependencyClient macro,

This unfortunately is not possible. We cannot access Swift settings in macros.