From 872583eca8b4e7ae6ef85917604d4a5257b9d125 Mon Sep 17 00:00:00 2001 From: Christian Cleberg Date: Wed, 22 Jul 2026 21:43:42 -0500 Subject: fix: adopt Swift 6 language mode; resolve all concurrency issues (#27) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit All three product targets (app, widget, share extension) now build under SWIFT_VERSION = 6.0 with zero errors and zero warnings. The UITests target stays on 5.0: XCTestCase's nonisolated setUp/init overrides conflict with the target's MainActor default isolation under 6, and test tooling is not shipping code. The original seven diagnostics, plus the layers Swift 6 mode surfaced once those cleared: - SMTPChannel is an actor. It was implicitly MainActor while running its receive loop on a background queue, so parsedLines/lineWaiters/ receiveBuffer were declared main-actor-protected and mutated off it — concurrent mutation while resuming a CheckedContinuation can double-resume, which traps. The actor serialises all state; Network callbacks hop in via Task. The start() continuation also gains an OSAllocatedUnfairLock resume-once guard: the state handler can fire .ready and later .failed, and resuming twice was a pre-existing trap of the same family. - CachedLookupResult is nonisolated (a value pair built inside actor LookupRuntime cannot have a MainActor-bound memberwise init) with conditional Sendable — opting out of MainActor isolation also opted out of the implicit Sendable that globally-isolated types get. - PortScanService.printableBanner is nonisolated: a pure transformation called from the connection's queue. - SweepActivityController stores the activity's Sendable id instead of the non-Sendable Activity, re-resolving via Activity.activities inside each fire-and-forget task, so nothing non-Sendable crosses isolation. - App Intents' static title/description/openAppWhenRun become lets (get-only protocol requirements; static var is shared mutable global state), and the summary helpers are @MainActor to match the model properties they read and the perform() implementations that call them. - ExternalDataService's ISO8601DateFormatter is nonisolated(unsafe), citing Apple's documented thread-safety, rather than risking a parser behaviour change by switching APIs with no test coverage. - TaskMetricsDelegate.metrics is nonisolated(unsafe): written on the session's delegate queue, read only after the request completes, and URLSession guarantees didFinishCollecting precedes task completion. - The share extension extracts the host via async/withCheckedContinuation instead of sending a non-Sendable completion into loadItem's @Sendable handler; Task inherits the view controller's MainActor so the manual DispatchQueue.main hop goes too. Validated: clean Swift 6 build of all product targets, and the full enforced 11-test audit suite green on the floor runtime — Swift 6's runtime isolation checks ran the app through every screen without a trap. --- DomainDig/SweepActivityController.swift | 39 +++++++++++++++++++++++---------- 1 file changed, 27 insertions(+), 12 deletions(-) (limited to 'DomainDig/SweepActivityController.swift') diff --git a/DomainDig/SweepActivityController.swift b/DomainDig/SweepActivityController.swift index a00bb2f..e6d179e 100644 --- a/DomainDig/SweepActivityController.swift +++ b/DomainDig/SweepActivityController.swift @@ -2,11 +2,18 @@ import ActivityKit import Foundation /// Starts, updates, and ends the sweep Live Activity around a batch run. +/// +/// Holds the activity's `id` (a Sendable `String`) rather than the +/// `Activity` object itself. `Activity` is not Sendable, and sending the +/// stored reference into the fire-and-forget update task while `self` still +/// held it was a Swift 6 region-isolation violation (issue #27). Each task +/// re-resolves the activity via `Activity.activities`, ActivityKit's +/// sanctioned lookup, so nothing non-Sendable crosses an isolation boundary. @MainActor final class SweepActivityController { static let shared = SweepActivityController() - private var activity: Activity? + private var activityID: String? private init() { /* Singleton; use the shared instance. */ } @@ -23,14 +30,15 @@ final class SweepActivityController { changed: 0, warnings: 0 ) - activity = try? Activity.request( + let activity = try? Activity.request( attributes: SweepActivityAttributes(title: title, startedAt: Date()), content: ActivityContent(state: state, staleDate: nil) ) + activityID = activity?.id } func update(completed: Int, total: Int, currentDomain: String?) { - guard let activity else { return } + guard let activityID else { return } let state = SweepActivityAttributes.ContentState( completed: completed, total: total, @@ -39,25 +47,32 @@ final class SweepActivityController { warnings: 0 ) Task { + guard let activity = Self.activity(withID: activityID) else { return } await activity.update(ActivityContent(state: state, staleDate: nil)) } } func end(changed: Int, warnings: Int, immediately: Bool = false) { - guard let activity else { return } - self.activity = nil - let state = SweepActivityAttributes.ContentState( - completed: activity.content.state.total, - total: activity.content.state.total, - currentDomain: nil, - changed: changed, - warnings: warnings - ) + guard let activityID else { return } + self.activityID = nil Task { + guard let activity = Self.activity(withID: activityID) else { return } + let total = activity.content.state.total + let state = SweepActivityAttributes.ContentState( + completed: total, + total: total, + currentDomain: nil, + changed: changed, + warnings: warnings + ) await activity.end( ActivityContent(state: state, staleDate: nil), dismissalPolicy: immediately ? .immediate : .after(Date().addingTimeInterval(60)) ) } } + + private nonisolated static func activity(withID id: String) -> Activity? { + Activity.activities.first { $0.id == id } + } } -- cgit v1.2.3