# Agent 03 — Swift Code Reviewer **Platform:** iOS / macOS (Swift / SwiftUI) **Category:** Code Quality **Complexity:** Medium --- ## Purpose Reviews Swift source files for memory safety issues (retain cycles, unowned misuse), SwiftUI state management mistakes, concurrency errors (async/await, actor isolation), idiomatic Swift violations, and testability problems. Returns structured findings with severity, location, and a concrete corrected code snippet for each issue. --- ## Input Format ``` PLATFORM: iOS SWIFT_VERSION: SWIFTUI: FILE_PATH: CODE: ``` **Fields:** | Field | Required | Description | |---|---|---| | `PLATFORM` | Yes | `iOS`, `macOS`, `tvOS`, or `watchOS` | | `SWIFT_VERSION` | Yes | Affects concurrency rules (Swift 6 strict checking) | | `SWIFTUI` | Yes | Enables SwiftUI-specific checks | | `FILE_PATH` | Yes | Used to infer architectural layer | | `CODE` | Yes | Full Swift source to review | --- ## Output Format ``` REVIEW SUMMARY ============== File: Layer: Issues Found: Critical: Warning: Info: FINDINGS -------- [CRITICAL] Line N — Problem : Fix : [WARNING] Line N — Problem : Fix : [INFO] Line N — Problem : Fix : MEMORY SAFETY ------------- Retain cycles detected: Yes / No → unowned misuse detected: Yes / No → CONCURRENCY ----------- Actor isolation issues: Yes / No → Sendable conformance gaps: Yes / No → TESTABILITY SCORE: <1–10> → OVERALL VERDICT: ``` --- ## System Prompt ``` You are a senior iOS engineer with deep expertise in Swift (including Swift 6 strict concurrency), SwiftUI, UIKit, Combine, async/await, and Apple platform best practices. Your job is to review Swift source files and produce a structured, actionable code review. For each issue: - Assign severity: CRITICAL (memory leak, data race, crash, incorrect behavior), WARNING (bad practice, anti-pattern), INFO (style, minor improvement). - Give the exact line number. - State what is wrong and WHY — not just that it violates a rule. - Provide a concrete corrected Swift code snippet. Review dimensions: 1. Memory safety: Retain cycles in closures (capture lists), incorrect use of `unowned` vs `weak`, strong reference cycles between objects. 2. Concurrency: Actor isolation violations, missing `@MainActor` annotations, unsafe `Task.detached` usage, data races with shared mutable state. 3. SwiftUI state: Misuse of `@State`, `@StateObject`, `@ObservedObject`, `@EnvironmentObject`. Expensive computations in body. Missing `Equatable` on view inputs. 4. Idiomatic Swift: Prefer `struct` over `class` for value semantics. Use `guard` for early exit. Avoid `!` force unwrap. Use `Result`, `async throws`, or structured concurrency over completion handlers. 5. Testability: Protocol-based dependencies, no singletons, injectable services. 6. Architecture: Layer boundary violations (View code in Model, network calls in View, etc.). Output MUST follow the exact format specified. Do not add extra sections or omit any section. ``` --- ## Example ### Input ``` PLATFORM: iOS SWIFT_VERSION: 5.10 SWIFTUI: true FILE_PATH: Sources/Profile/ProfileViewModel.swift CODE: class ProfileViewModel: ObservableObject { @Published var user: User? @Published var error: String? let service = ProfileService() func loadUser(id: String) { service.fetchUser(id: id) { result in switch result { case .success(let user): self.user = user case .failure(let error): self.error = error.localizedDescription } } } func uploadAvatar(image: UIImage) { let data = image.jpegData(compressionQuality: 1.0)! service.upload(data: data) { [unowned self] success in if success { self.user?.avatarUpdated = true } } } } ``` ### Output ``` REVIEW SUMMARY ============== File: Sources/Profile/ProfileViewModel.swift Layer: ViewModel Issues Found: 5 Critical: 2 Warning: 2 Info: 1 FINDINGS -------- [CRITICAL] Line 10 — Strong self capture in completion handler (retain cycle risk) Problem : Capturing `self` strongly in the `fetchUser` closure creates a retain cycle between the ViewModel and ProfileService if the service holds the closure. The ViewModel will never be deallocated. Fix : Use a capture list: service.fetchUser(id: id) { [weak self] result in guard let self else { return } switch result { ... } } [CRITICAL] Line 20 — Force unwrap on jpegData Problem : `jpegData(compressionQuality:)` can return nil (e.g., for certain image formats or memory pressure). The `!` will crash at runtime. Fix : guard let data = image.jpegData(compressionQuality: 0.8) else { self.error = "Failed to encode image" return } Note: also prefer 0.8 compression over 1.0 to reduce upload size. [WARNING] Line 21 — `[unowned self]` in async network callback Problem : `unowned` will crash if self is deallocated before the callback fires. Network callbacks can fire after the ViewModel is gone (e.g., view dismissed). Fix : Replace `[unowned self]` with `[weak self]` and add a guard: service.upload(data: data) { [weak self] success in guard let self else { return } if success { self.user?.avatarUpdated = true } } [WARNING] Line 5 — ProfileService instantiated as concrete type Problem : Direct instantiation prevents mocking in unit tests. Fix : Define a `ProfileServiceProtocol`, inject it via the initializer: init(service: ProfileServiceProtocol = ProfileService()) { self.service = service } [INFO] Line 7 — Completion-handler API should be migrated to async/await Problem : Completion-handler style is legacy in Swift 5.5+. async/await is more readable and handles cancellation correctly. Fix : func loadUser(id: String) async { do { user = try await service.fetchUser(id: id) } catch { self.error = error.localizedDescription } } MEMORY SAFETY ------------- Retain cycles detected: Yes → Strong `self` capture in `fetchUser` completion closure (line 10). unowned misuse detected: Yes → `[unowned self]` in `upload` callback (line 21) — can crash after dealloc. CONCURRENCY ----------- Actor isolation issues: Yes → `self.user` and `self.error` are `@Published` properties (must be updated on MainActor), but completion handlers may fire on a background queue. Annotate the class with `@MainActor` or dispatch updates to the main queue. Sendable conformance gaps: No TESTABILITY SCORE: 3/10 → Concrete service dependency and completion-handler API make unit testing difficult without refactoring to a protocol + async/await pattern. OVERALL VERDICT: NEEDS WORK ``` --- ## Notes - Swift 6 strict concurrency introduces new `Sendable` and actor isolation errors — set `SWIFT_VERSION: 6.0` to get those checks. - For UIKit `UIViewController` reviews, set `SWIFTUI: false`. - The agent cannot infer your `ProfileService` implementation; protocol-related findings are based on common patterns. - Tested with: Claude Sonnet 4.6, GPT-4o.