@DependencyClient generates invalid @Sendable` function when closure parameter has a named argument

[mehmetbaykar]

Description

Description

There seems to be an issue in Dependencies Macros when using @DependencyClient with a closure that explicitly names its parameter.

The macro-generated code differs depending on whether the closure includes a parameter name in its declaration. This inconsistency leads to invalid generated code and a compiler error.

Example

✅ This works as expected:

@DependencyClient
public struct AnalyticsClient {
    public var startWithPath: @Sendable (String) -> Bool = { path in
        return false
    }
}

❌ This fails:

@DependencyClient
public struct AnalyticsClient {
    public var start: @Sendable (_ path: String) -> Bool = { path in
        return false
    }
}

Generated Code

The macro expansion produces:

@Sendable
public func start(path p0: String) -> Bool {
    self.start(p0)
}

private var _start: @Sendable (_ path: String) -> Bool = { path in
    IssueReporting.reportIssue("Unimplemented: '\(Self.self).start'")
    return false
}

Error

Main actor-isolated synchronous instance method 'start(path:)' cannot be marked as '@Sendable'

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

Both forms of closure declarations (with or without parameter names) should compile without errors. The macro should generate consistent and valid code for either case.

Environment

• Swift Package Settings:

[
        .defaultIsolation(MainActor.self),
        .enableUpcomingFeature("NonisolatedNonsendingByDefault"),
        .enableUpcomingFeature("InferIsolatedConformances"),
]

Actual behavior

No response

Steps to reproduce

No response

Dependencies version information

1.10.0

Destination operating system

iOS 26.0

Xcode version information

xCode 26.0

Swift Compiler version information

swift-driver version: 1.127.14.1 Apple Swift version 6.2 (swiftlang-6.2.0.19.9 clang-1700.3.19.1)
Target: arm64-apple-macosx26.0

[mbrandonw]

Hi @mehmetbaykar, there is no need to mark your closure as @Sendable since you are using default main actor isolation and so the whole dependency is main actor. And there is no way for the macro to diagnose this because it doesn't know you are using default main actor isolation.

However, I still don't think that will work because key paths on main actor types are not sendable, and so you won't be able to use @Dependency(\.analytics). I think the real solution here is to mark your dependency as nonisolated, which is a pretty common thing to have to do when dealing with default main actor isolation.

Since this isn't an issue with the library I am going to convert it to a discussion. Please feel free to continue the conversation over there!

[mehmetbaykar]

Question: Best practices for @MainActor with Point-Free dependencies

Hi @mbrandonw, I'm working with Point-Free's libraries and encountering a Sendable conformance issue when using strict concurrency settings. What's the recommended approach?

Context

The following dependency works without these Swift settings:

.defaultIsolation(MainActor.self),
.enableUpcomingFeature("NonisolatedNonsendingByDefault"),
.enableUpcomingFeature("InferIsolatedConformances"),

Working Code (without strict settings)

@DependencyClient
public struct URLValidator: Sendable {
  public var validate: @Sendable (URL) -> Bool = { _ in true }
  public var validateWithHosts: @Sendable (_ url: URL, _hosts: [String]) -> Bool = { _, _ in
    true
  }
}

extension URLValidator: TestDependencyKey {
  public static var previewValue: URLValidator {
    .alwaysValid
  }
  public static var testValue: URLValidator {
    .alwaysValid
  }
}

Failing Code (with strict settings enabled)

When I enable the MainActor settings above and mark the dependency as nonisolated:

@DependencyClient
nonisolated public struct URLValidator {
  public var validate: (URL) -> Bool = { _ in true }
  public var validateWithHosts: (_ url: URL, _hosts: [String]) -> Bool = { _, _ in
    true
  }
}

extension URLValidator: TestDependencyKey {
  public static var previewValue: URLValidator {
    .testValue
  }
  public static var testValue: URLValidator {
    .previewValue
  }
}

Error on this line:

extension URLValidator: TestDependencyKey {

Error message:

Type 'URLValidator' does not conform to the 'Sendable' protocol

Question

What's the best solution here? Should I:

1. Keep using @MainActor and explicit Sendable conformance with @Sendable closures?
2. Use nonisolated differently?
3. Follow a different pattern recommended for Point-Free's libraries with strict concurrency?

[mbrandonw]

If you are going the nonisolated route you need to make the closures @Sendable.