Swift Concurrency Pro

1---2name: swift-concurrency-pro3description: Reviews Swift code for concurrency correctness, modern API usage, and common async/await pitfalls. Use when reading, writing, or reviewing Swift concurrency code.4license: MIT5metadata:6  author: Paul Hudson7  version: "1.0"8---9 10Review Swift concurrency code for correctness, modern API usage, and adherence to project conventions. Report only genuine problems - do not nitpick or invent issues.11 12Review process:13 141. Scan for known-dangerous patterns using `references/hotspots.md` to prioritize what to inspect.151. Check for recent Swift 6.2 concurrency behavior using `references/new-features.md`.161. Validate actor usage for reentrancy and isolation correctness using `references/actors.md`.171. Ensure structured concurrency is preferred over unstructured where appropriate using `references/structured.md`.181. Check unstructured task usage for correctness using `references/unstructured.md`.191. Verify cancellation is handled correctly using `references/cancellation.md`.201. Validate async stream and continuation usage using `references/async-streams.md`.211. Check bridging code between sync and async worlds using `references/bridging.md`.221. Review any legacy concurrency migrations using `references/interop.md`.231. Cross-check against common failure modes using `references/bug-patterns.md`.241. If the project has strict-concurrency errors, map diagnostics to fixes using `references/diagnostics.md`.251. If reviewing tests, check async test patterns using `references/testing.md`.26 27If doing a partial review, load only the relevant reference files.28 29 30## Core Instructions31 32- Target Swift 6.2 or later with strict concurrency checking.33- If code spans multiple targets or packages, compare their concurrency build settings before assuming behavior should match.34- Prefer structured concurrency (task groups) over unstructured (`Task {}`).35- Prefer Swift concurrency over Grand Central Dispatch for new code. GCD is still acceptable in low-level code, framework interop, or performance-critical synchronous work where queues and locks are the right tool – don't flag these as errors.36- If an API offers both `async`/`await` and closure-based variants, always prefer `async`/`await`.37- Do not introduce third-party concurrency frameworks without asking first.38- Do not suggest `@unchecked Sendable` to fix compiler errors. It silences the diagnostic without fixing the underlying race. Prefer actors, value types, or `sending` parameters instead. The only legitimate use is for types with internal locking that are provably thread-safe.39 40 41## Output Format42 43Organize findings by file. For each issue:44 451. State the file and relevant line(s).462. Name the rule being violated.473. Show a brief before/after code fix.48 49Skip files with no issues. End with a prioritized summary of the most impactful changes to make first.50 51Example output:52 53### DataLoader.swift54 55**Line 18: Actor reentrancy – state may have changed across the `await`.**56 57```swift58// Before59actor Cache {60    var items: [String: Data] = [:]61 62    func fetch(_ key: String) async throws -> Data {63        if items[key] == nil {64            items[key] = try await download(key)65        }66        return items[key]!67    }68}69 70// After71actor Cache {72    var items: [String: Data] = [:]73 74    func fetch(_ key: String) async throws -> Data {75        if let existing = items[key] { return existing }76        let data = try await download(key)77        items[key] = data78        return data79    }80}81```82 83**Line 34: Use `withTaskGroup` instead of creating tasks in a loop.**84 85```swift86// Before87for url in urls {88    Task { try await fetch(url) }89}90 91// After92try await withThrowingTaskGroup(of: Data.self) { group in93    for url in urls {94        group.addTask { try await fetch(url) }95    }96 97    for try await result in group {98        process(result)99    }100}101```102 103### Summary104 1051. **Correctness (high):** Actor reentrancy bug on line 18 may cause duplicate downloads and a force-unwrap crash.1062. **Structure (medium):** Unstructured tasks in loop on line 34 lose cancellation propagation.107 108End of example.109 110 111## References112 113- `references/hotspots.md` - Grep targets for code review: known-dangerous patterns and what to check for each.114- `references/new-features.md` - Swift 6.2 changes that alter review advice: default actor isolation, isolated conformances, caller-actor async behavior, `@concurrent`, `Task.immediate`, task naming, and priority escalation.115- `references/actors.md` - Actor reentrancy, shared-state annotations, global actor inference, and isolation patterns.116- `references/structured.md` - Task groups over loops, discarding task groups, concurrency limits.117- `references/unstructured.md` - Task vs Task.detached, when Task {} is a code smell.118- `references/cancellation.md` - Cancellation propagation, cooperative checking, broken cancellation patterns.119- `references/async-streams.md` - AsyncStream factory, continuation lifecycle, back-pressure.120- `references/bridging.md` - Checked continuations, wrapping legacy APIs, `@unchecked Sendable`.121- `references/interop.md` - Migrating from GCD, `Mutex`/locks, completion handlers, delegates, and Combine.122- `references/bug-patterns.md` - Common concurrency failure modes and their fixes.123- `references/diagnostics.md` - Strict-concurrency compiler errors, protocol conformance fixes, and likely remedies.124- `references/testing.md` - Async test strategy with Swift Testing, race detection, avoiding timing-based tests.