@DependencyClient async closure parameters appear uninitialized / crash when accessed under Swift 6

[zangqilong198812]

Description

Summary

When using @DependencyClient with an async @Sendable function that takes multiple parameters, the generated closure sometimes crashes as soon as I touch the parameters inside the liveValue implementation.

• The call site sees correct values.
• The dependency closure is definitely entered (first print runs).
• But reading the parameters inside the closure causes an immediate crash, and LLDB reports them as <uninitialized> / invalid memory.

This happens only with the @DependencyClient macro. The same code path, when implemented as a manual DependencyKey (without @DependencyClient), does not show this behavior.

---

Environment

• Xcode: 26.1.1
• Swift: Swift 6 language mode (the project is compiled with Swift 6 mode enabled)
• Platform: iOS 26.0 iPhone 17 Pro max)
• Architecture: arm64
• Dependencies:
  • pointfreeco/swift-dependencies version: 1.10
  • pointfreeco/swift-composable-architecture version: 1.23.1

---

Code

Dependency definition

import ComposableArchitecture
import Dependencies
import Foundation

extension DependencyValues {
    var ragService: RAGServiceDependency {
        get { self[RAGServiceDependency.self] }
        set { self[RAGServiceDependency.self] = newValue }
    }
}

@DependencyClient
struct RAGServiceDependency {
    /// Index a single document
    var index: @Sendable (String, UUID?) async throws -> Void
    /// Batch index
    var indexMultiple: @Sendable ([String], [UUID]?) async throws -> [UUID]
    /// Update document
    var update: @Sendable (UUID, String) async throws -> Void
    /// Delete documents
    var delete: @Sendable ([UUID]) async throws -> Void
    /// Reset DB
    var reset: @Sendable () async throws -> Void
    /// Count
    var documentCount: @Sendable () async throws -> Int
    /// RAG answer
    var answer: @Sendable (String, Int?, Float?) async throws -> RAGAnswer
}

extension RAGServiceDependency: DependencyKey {
    static let liveValue = Self(
        index: { text, id in
            // 1️⃣ This prints fine
            print("🔥🔥🔥 ENTER rag.index closure")

            // 2️⃣ Accessing parameters here will crash
            print("🔥 rag.index called with:", text.prefix(40), "id:", id as Any)

            let engine = try await RAGEngineManager.shared.getEngine()
            try await engine.index(text: text, id: id)
        },
        indexMultiple: { texts, ids in
            let engine = try await RAGEngineManager.shared.getEngine()
            return try await engine.index(texts: texts, ids: ids)
        },
        update: { id, newText in
            let engine = try await RAGEngineManager.shared.getEngine()
            try await engine.update(id: id, newText: newText)
        },
        delete: { ids in
            let engine = try await RAGEngineManager.shared.getEngine()
            try await engine.delete(ids: ids)
        },
        reset: {
            let engine = try await RAGEngineManager.shared.getEngine()
            try await engine.reset()
        },
        documentCount: {
            let engine = try await RAGEngineManager.shared.getEngine()
            return try await engine.documentCount()
        },
        answer: { question, topK, minScore in
            let engine = try await RAGEngineManager.shared.getEngine()
            return try await engine.answer(question: question, topK: topK, minScore: minScore)
        }
    )

    static let testValue = Self(
        index: { _, _ in },
        indexMultiple: { _, _ in [] },
        update: { _, _ in },
        delete: { _ in },
        reset: {},
        documentCount: { 0 },
        answer: { _, _, _ in RAGAnswer(answer: "Test answer", usedChunkCount: 0) }
    )
}

RAGEngineManager is an actor-based singleton, but the crash happens before it is used (just by printing text / id).
Usage in a reducer

@Reducer
struct NoteFeature {
    struct State { ... }
    enum Action {
        case noteExported(Note)
        ...
    }

    @Dependency(\.ragService) var rag

    func reduce(into state: inout State, action: Action) -> Effect<Action> {
        switch action {
        case let .noteExported(note):
            return .run { _ in
                // Call site log – this prints correct values
                print("👀 call rag.index with:", note.analyzeDescription.prefix(40), "id:", note.id as Any)
                try await rag.index(note.analyzeDescription, note.id)
            }
        ...
        }
    }
}

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

•	The parameters text: String and id: UUID? should be safely accessible inside the liveValue.index closure.
•	print("...", text.prefix(40), "id:", id as Any) should not crash.

Actual behavior

When rag.index is called:

1. At the call site, I see:

👀 call rag.index with: Text Note
created 2025-12-08 14:30
id: 7DC8827A-8E5B-4210-AF47-BEEBCDA30E89

2. Inside the dependency closure, with the temporary logging:

print("🔥🔥🔥 ENTER rag.index closure")
print("🔥 rag.index called with:", text.prefix(40), "id:", id as Any)

the output is:

"checked database changed"
"checked database changed"
🔥🔥🔥 ENTER rag.index closure

3. In LLDB, inspecting the parameters inside the closure frame shows:

text    String      <uninitialized>   _guts _StringGuts
id      UUID?       <LLDB error: read memory from 0x0 failed (0 of 17 bytes read)>

4. Inspecting liveValue in LLDB shows the _index implementation is a reabstraction thunk with an extra Optional parameter:

_index nonisolated(nonsending) @Sendable (String, Foundation.UUID?) async throws -> ()
0x... QuickIdea.debug.dylib`partial apply forwarder for reabstraction thunk helper
from @escaping @callee_guaranteed @Sendable @async (@guaranteed Swift.Optional<Swift.Actor>, @guaranteed Swift.String, @in_guaranteed Swift.Optional<Foundation.UUID>) -> (@error @owned Swift.Error)
to   @escaping @callee_guaranteed @async (@guaranteed Swift.String, @in_guaranteed Swift.Optional<Foundation.UUID>) -> (@error @owned Swift.Error)

There is no manual use of unsafe pointers, C APIs, or force-unwrapping in this path. The only thing that happens before the crash is trying to read text / id in the dependency closure.

Steps to reproduce

No response

Dependencies version information

1.10.0

Destination operating system

ios 26.0

Xcode version information

26.1.1

Swift Compiler version information

swift-driver version: 1.127.14.1 Apple Swift version 6.2.1 (swiftlang-6.2.1.4.8 clang-1700.4.4.1)
Target: arm64-apple-macosx26.0

[mbrandonw]

Hi @zangqilong198812, please provide a minimal project that reproduces this problem. It's not possible to diagnose from the code snippets you have provided. Also, I doubt this issue has anything to do with TCA, so I would focus on creating a repro that just uses Dependencies.

And almost this exact issue came up recently, and it was released to Swift 5 mode. I know you say you are using Swift 6 mode, but your crash is basically identical and so that is why a reproducing project would be helpful for us to investigate.

And further, if there really is an issue here it seems almost certainly a Swift bug, either in macros or its concurrency system. And so for now I am going to convert this to a discussion and we can continue the conversation over there.