DependencyClient macro leads to uninitialized parameters

[bugix]

Excuse my stupid question but what could be the issue with this code, which crashes due to uninitialized parameters. Removing the @DependencyClient macro resolves the issue but I'd like to keep it for the argument labels.

@DependencyClient
public struct MyDependency {
    public var test: (_ one: String, _ two: String) async throws -> Void
}

extension MyDependency: DependencyKey {
    public static var liveValue: Self {
        return Self(
            test: { one, two in
                print("Calling test with \(one) and \(two)")
            }
        )
    }
}

extension DependencyValues {
    var myDependency: MyDependency {
        get { self[MyDependency.self] }
        set { self[MyDependency.self] = newValue }
    }
}

@Reducer
struct Content {

    @ObservableState
    struct State: Equatable {
    }

    enum Action {
        case tapped
    }

    @Dependency(\.myDependency) var myDependency

    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .tapped:
                return .run { send in
                    try await myDependency.test("one", "two")
                }
            }
        }
    }
}

[mbrandonw]

Hi @bugix, this code does not crash for me. Are you sure it actually crashes?

I do see a test failure:

🛑 foo(): Issue recorded: @dependency(.myDependency) has no test implementation, but was accessed from a test context:

Location:
DependenciesMacrosPluginTests/DependencyClientTests.swift:89
Dependency:
MyDependency

Dependencies registered with the library are not allowed to use their default, live implementations when run from tests.

To fix, override 'myDependency' with a test value. If you are using the Composable Architecture, mutate the 'dependencies' property on your 'TestStore'. Otherwise, use 'withDependencies' to define a scope for the override. If you'd like to provide a default value for all tests, implement the 'testValue' requirement of the 'DependencyKey' protocol.

But that is to be expected. By default accessing a dependency in a test is a test failure because typically you should be forced to override that dependency so that you don't accidentally access a live dependency in tests.

[bugix]

Hi @mbrandonw , thanks for the quick answer.

Yes, I think it crashes or at least throws a "EXC_BAD_ACCESS" error.

I did not create a test target, so I don't belive the missing test value is the issue. The project was created by Xcode 26.1.1 with the default (concurrency-)settings. Maybe I miss some needed adjustments there? I uploaded the project to https://github.com/bugix/DependencyPoc

[mbrandonw]

Hi @bugix, thanks for providing the project, now I see what you are talking about.

Sadly this is just a sharp edge of using Swift 5 language mode with modern concurrency tools and minimal concurrency checking. It leads to compiling code that can crash at runtime. The crux of the problem is that you are using default main actor isolation, so everything is implicitly main actor, but key paths on main actor types are not Sendable, and that can lead to accessing main actor data on non-main threads. And because you are using Swift 5 mode and "minimal" concurrency checking (the default in Xcode), there is no warning or error about this problem.

Due to the fact that Swift has lots of "modes" and "settings" to customize how it behaves (approach concurrency, default isolation, language mode, concurrency checking), there are a lot of ways to fix this depending on how you want to structure your project.

If you want to keep your project settings exactly as they are now (Swift 5 mode, approach concurrency, default main actor isolation, minimal checking), then you need to be vigilant in making your dependencies nonisolated so that Swift doesn't crash at runtime when it seems you accessing a key path on a non-main thread:

@DependencyClient
           👇
public nonisolated struct MyDependency {
  public var test: (_ one: String, _ two: String) async throws -> Void
}
                            👇
extension MyDependency: nonisolated DependencyKey {
              👇
  public nonisolated static var liveValue: Self {
    …
  }
}
extension DependencyValues {
      👇
  nonisolated var myDependency: MyDependency {
    …
  }
}

That's right, all of that is needed, and the compiler doesn't help you at all to know that. (Note: The 2nd and 3rd nonisolateds would not be needed if you defined the DependencyKey conform directly on the struct instead of as an extension)

You could also turn off "approachable concurrency" to fix this. I wouldn't personally do that because the plan is for that umbrella of settings to become the default of Swift someday. You could also turn off default main actor isolation, which I personally would recommend because it will not become the default of Swift and it is a very difficult thing to make work in practice.

But my personal preference would be for you either to turn concurrency checking to "Complete" or flip to Swift 6 language mode. That would have immediately given you a warning or error letting you know something isn't right:

@Dependency(\.myDependency) var myDependency
// 🛑 Type 'WritableKeyPath<DependencyValues, MyDependency>' does not conform to the 'Sendable' protocol

[bugix]

Thanks @mbrandonw , I was able to fix and partially understand the issue. Looking forward to Back to basics: Concurrency!

Funny thing is that switching concurrency checking to "Complete" alone fixes the crash, which is weird as this is only a linter in my view.