Swift Concurrency Migration and Data Race Analysis

Role: Lead iOS Systems Architect specializing in Swift Concurrency, Sendable safety, and GCD-to-Async migration.

Context

• Target subsystem name: {{subsystem_name}}
• Existing threading logic: {{legacy_dispatch_logic}}
• Project Swift language mode: {{swift_language_mode}}
• Shared state properties: {{shared_mutable_state}}
• Throughput and latency expectations: {{performance_criticality}}
• External concurrency dependencies: {{third_party_dependencies}}

Task

Generate a rigorous concurrency analysis and actor-based migration architecture for {{subsystem_name}} that eliminates data races in {{shared_mutable_state}} while satisfying {{swift_language_mode}} strict checking requirements.

Method

1. Audit {{legacy_dispatch_logic}} to pinpoint thread hops, locks, and manual queue synchronizations.
2. Evaluate all types participating in {{shared_mutable_state}} for Sendable conformance and value-type safety.
3. Analyze potential actor isolation crossings and non-isolated boundary leaks considering {{third_party_dependencies}}.
4. Determine whether an Actor, GlobalActor (such as MainActor), or TaskGroup is required for {{subsystem_name}}.
5. Model deadlocks, reentrancy vulnerabilities, and executor contention risks under {{performance_criticality}} constraints.
6. Architect the modern Swift async/await replacement pattern to deprecate callback-based dispatch queues.
7. Formulate a stepwise migration plan that preserves binary compatibility during rollout.

Constraints

• MUST address Swift 6 strict concurrency checks explicitly for {{swift_language_mode}}.
• MUST identify and solve actor reentrancy risks in asynchronous critical paths.
• MUST NOT introduce arbitrary Task sleeps or unchecked Sendable workarounds.
• Keep architectural changes scoped directly to the boundaries of {{subsystem_name}}.

Output format

• Concurrency Risk Assessment (ranked list of current race conditions)
• Actor Isolation Architecture Plan (actor definitions and boundary model)
• Refactored Swift Concurrency Code (complete replacement implementation)
• Actor Reentrancy & Deadlock Defense (technical risk mitigation review)
• Migration & Testing Strategy (phased rollout with unit test examples)

Self-review

• Are all shared mutable properties in {{shared_mutable_state}} protected by actors or Sendable guarantees?
• Does the migration handle {{third_party_dependencies}} integration boundaries safely?
• Did I verify actor reentrancy scenarios across suspension points?