Swift 6 Migration (#5733)

* Enable Swift 6.2 with default main actor isolation for the app target

Turn on SWIFT_VERSION 6.2, SWIFT_APPROACHABLE_CONCURRENCY and SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor for the ElementX target, matching the NSE and Share Extension (which already use 6.2 without the main actor default).

# Conflicts:
#	ElementX.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

* Update the code generation templates for Swift 6

Emit nonisolated/@unchecked Sendable mocks and nonisolated string enums, and mark async mock methods @concurrent so they keep suspending like the real implementations (otherwise intermediate states are unobservable in tests). Includes the regenerated mocks and strings.

# Conflicts:
#	ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

* Make the data layer and services nonisolated and Sendable

Annotate the value-type models, Rust SDK proxy wrappers, timeline item graph, settings, logging and NSE-shared types as nonisolated, and conform the service protocols to Sendable so their existentials can cross isolation boundaries. These types run off the main actor and no longer inherit the target's default main actor isolation.

* Adopt the new isolation across call sites, mocks and signatures

Update call sites, closure signatures and mock configuration helpers to match the nonisolated/Sendable data layer, including the main actor isolated mock inits and the @Sendable filter on recentlyVisitedRooms.

^ Conflicts:
^	ElementX/Sources/Services/SecureBackup/SecureBackupController.swift

* Remove redundant @MainActor annotations

With the app target defaulting to main actor isolation, the explicit @MainActor on view models, coordinators, views and their protocols is no longer required.

* Fix concurrency hotspots surfaced by the migration

Resolve the room summary main-thread deadlock by moving diff processing onto AsyncStreams, add the SDKListener.onMainActor FIFO bridge for SDK callbacks, hop KVO/timer/UIKit callbacks to the main actor via assumeIsolated, add isolated deinits, and apply the few justified nonisolated(unsafe) escapes for queue-confined Apple APIs.

* Fix the unit tests for Swift 6 concurrency

Hop the waitForConfirmation body onto the caller's actor (Swift Testing runs confirmation closures off-actor), and adjust the affected suites and async signatures.

* offload diffs on concurrent threads instead of main actor

* make room info protocols sendable

* use a task group for fetching data so that everything runs concurrently in the TextRoomTimelineView when getting the preview.

* use the generic onMainActor implementation, which already makes a stream and send the continuation on the main actor.

* small pr comments issues being addressed

* update enterprise

* Update StaticCode to 1.1.0 and specify the required Swift isolation.

* fix ElementCallServiceTests

* update enterprise

* re-generate mocks

* update enterprise

* enterprise new code conformed to swift 6

---------

Co-authored-by: Doug <douglase@element.io>

UnitTests/Sources/AnalyticsTests.swift

@@ -11,13 +11,13 @@ import AnalyticsEvents
 import PostHog
 import Testing
 
+@MainActor
 final class AnalyticsTests {
     private let appSettings: AppSettings
     private let analytics: AnalyticsServiceProtocol
     private let analyticsClient: AnalyticsClientMock
     private var posthogMock: PHGPostHogMock
     
-    @MainActor
     init() {
         appSettings = AppSettings.volatile()
         

UnitTests/Sources/AppRouteURLParserTests.swift

@@ -10,6 +10,7 @@
 import Foundation
 import Testing
 
+@MainActor
 struct AppRouteURLParserTests {
     var appSettings: AppSettings
     var appRouteURLParser: AppRouteURLParser

UnitTests/Sources/BugReportServiceTests.swift

@@ -11,6 +11,7 @@ import Combine
 import Foundation
 import Testing
 
+@MainActor
 final class BugReportServiceTests {
     var appSettings: AppSettings!
     var bugReportService: BugReportServiceProtocol!
@@ -76,7 +77,7 @@ final class BugReportServiceTests {
         #expect(!service.crashedLastRun)
     }
     
-    @Test @MainActor
+    @Test
     func submitBugReportWithRealService() async throws {
         let urlPublisher: CurrentValueSubject<RageshakeConfiguration, Never> = .init(.url("https://example.com/submit"))
         let service = BugReportService(rageshakeURLPublisher: urlPublisher.asCurrentValuePublisher(),

UnitTests/Sources/ClassicAppAccountManagerTests.swift

@@ -9,6 +9,7 @@
 import Foundation
 import Testing
 
+@MainActor
 final class ClassicAppAccountManagerTests {
     let testDirectory: URL = .temporaryDirectory.appending(component: UUID().uuidString)
     let accountAESKey: Data
@@ -68,6 +69,7 @@ final class ClassicAppAccountManagerTests {
     }
 }
 
+@MainActor
 extension ClassicAppAccount {
     /// Creates a mock account based on the fixtures used by this test.
     static func mock(classicAppAccountManager: ClassicAppAccountManager, cryptoStorePassphrase: Data) -> ClassicAppAccount {

UnitTests/Sources/ClassicAppMediaLoaderTests.swift

@@ -14,6 +14,7 @@ final class ClassicAppMediaLoaderTests {
     let mediaLoader: ClassicAppMediaLoader
     let urlSession: URLSession
     
+    @MainActor
     init() throws {
         account = ClassicAppAccount(userID: "@alice:matrix.org",
                                     displayName: nil,
@@ -40,6 +41,7 @@ final class ClassicAppMediaLoaderTests {
         #expect(data == MockURLProtocol.downloadData)
     }
     
+    @MainActor
     @Test
     func loadMediaContentWithInvalidToken() async throws {
         let accountWithoutToken = ClassicAppAccount(userID: "@bob:matrix.org",

UnitTests/Sources/ElementCallServiceTests.swift

@@ -41,7 +41,7 @@ final class ElementCallServiceTests {
     func incomingCall() async {
         #expect(!callProvider.reportNewIncomingCallWithUpdateCompletionCalled)
         
-        await confirmation { confirmation in
+        await waitForConfirmation { confirmation in
             let pkPushPayloadMock = PKPushPayloadMock().updatingExpiration(currentDate, lifetime: 30)
             
             service.pushRegistry(pushRegistry, didReceiveIncomingPushWith: pkPushPayloadMock, for: .voIP) {
@@ -62,7 +62,7 @@ final class ElementCallServiceTests {
     func incomingVoiceCall() async {
         #expect(!callProvider.reportNewIncomingCallWithUpdateCompletionCalled)
         
-        await confirmation { confirmation in
+        await waitForConfirmation { confirmation in
             let pkPushPayloadMock = PKPushPayloadMock().updatingExpiration(currentDate, lifetime: 30)
                 .updateIsVoice(true)
             
@@ -162,7 +162,7 @@ final class ElementCallServiceTests {
         
         // Send push #2 for the same room; the previous incoming state must be cleared,
         // so the second push gets a fresh CallID.
-        await confirmation { confirmation in
+        await waitForConfirmation { confirmation in
             let secondPayload = PKPushPayloadMock().updatingExpiration(currentDate, lifetime: 60)
             service.pushRegistry(pushRegistry, didReceiveIncomingPushWith: secondPayload, for: .voIP) {
                 confirmation()
@@ -182,7 +182,7 @@ final class ElementCallServiceTests {
     @Test
     func setupCallSessionCancelsPendingUnansweredTimeout() async {
         // Schedule the 60s unanswered timer via an incoming push
-        await confirmation { confirmation in
+        await waitForConfirmation { confirmation in
             let payload = PKPushPayloadMock().updatingExpiration(currentDate, lifetime: 60)
             service.pushRegistry(pushRegistry, didReceiveIncomingPushWith: payload, for: .voIP) {
                 confirmation()
@@ -240,7 +240,7 @@ final class ElementCallServiceTests {
         let baselineNewIncomingCount = callProvider.reportNewIncomingCallWithUpdateCompletionCallsCount
         let baselineEndedCount = callProvider.reportCallWithEndedAtReasonCallsCount
         
-        await confirmation { confirmation in
+        await waitForConfirmation { confirmation in
             service.pushRegistry(pushRegistry, didReceiveIncomingPushWith: payload, for: .voIP) {
                 confirmation()
             }

UnitTests/Sources/HomeScreenViewModelTests.swift

@@ -441,6 +441,7 @@ final class HomeScreenViewModelTests {
     }
 }
 
+@MainActor
 private extension [HomeScreenRoom] {
     var invites: [HomeScreenRoom] {
         filter { room in
@@ -453,7 +454,8 @@ private extension [HomeScreenRoom] {
     }
 }
 
-extension HomeScreenViewModelAction: @retroactive Equatable {
+@MainActor
+extension HomeScreenViewModelAction: @MainActor @retroactive Equatable {
     public static func == (lhs: HomeScreenViewModelAction, rhs: HomeScreenViewModelAction) -> Bool {
         switch (lhs, rhs) {
         case (.presentRoom(let lhsID), .presentRoom(let rhsID)):

UnitTests/Sources/JoinRoomScreenViewModelTests.swift

@@ -207,7 +207,8 @@ final class JoinRoomScreenViewModelTests {
     }
 }
 
-extension JoinRoomScreenViewModelAction: @retroactive Equatable {
+@MainActor
+extension JoinRoomScreenViewModelAction: @MainActor @retroactive Equatable {
     /// A close enough approximation for tests.
     public static func == (lhs: JoinRoomScreenViewModelAction, rhs: JoinRoomScreenViewModelAction) -> Bool {
         switch (lhs, rhs) {

UnitTests/Sources/LocationSharingScreenViewModelTests.swift

@@ -241,7 +241,7 @@ struct LocationSharingScreenViewModelTests {
     }
     
     @Test
-    mutating func startLiveLocationWithNotDeterminedAuthorizationTransitionsToWhenInUse() async {
+    mutating func startLiveLocationWithNotDeterminedAuthorizationTransitionsToWhenInUse() {
         let authorizationStatusSubject = CurrentValueSubject<CLAuthorizationStatus, Never>(.notDetermined)
         let liveLocationManagerMock = LiveLocationManagerMock()
         liveLocationManagerMock.authorizationStatus = .init(authorizationStatusSubject)
@@ -252,16 +252,14 @@ struct LocationSharingScreenViewModelTests {
         
         // No alert yet — waiting for MapLibre to resolve the status to whenInUse
         #expect(context.alertInfo == nil)
+        #expect(!liveLocationManagerMock.requestAlwaysAuthorizationIfPossibleCalled)
         
-        // Simulate MapLibre resolving the Authorization to whenInUse, and confirm that the ViewModel
-        // recurses and calls requestAlwaysAuthorizationIfPossible as a result
-        await waitForConfirmation { confirmation in
-            liveLocationManagerMock.requestAlwaysAuthorizationIfPossibleClosure = {
-                confirmation()
-                return true
-            }
-            authorizationStatusSubject.send(.authorizedWhenInUse)
-        }
+        // Simulate MapLibre resolving the Authorization to whenInUse. The subject delivers
+        // synchronously on the main actor, so the ViewModel recurses and calls
+        // requestAlwaysAuthorizationIfPossible before send returns.
+        authorizationStatusSubject.send(.authorizedWhenInUse)
+        
+        #expect(liveLocationManagerMock.requestAlwaysAuthorizationIfPossibleCalled)
         
         // The request was made, so no alert — waiting for the always Authorization prompt response
         #expect(context.alertInfo == nil)

UnitTests/Sources/LoggingTests.swift

@@ -12,6 +12,7 @@ import Foundation
 import MatrixRustSDKMocks
 import Testing
 
+@MainActor
 final class LoggingTests {
     private enum Constants {
         static let genericFailure = "Test failed"

UnitTests/Sources/MapTilerURLBuilderTests.swift

@@ -10,6 +10,7 @@ import CoreLocation
 @testable import ElementX
 import Testing
 
+@MainActor
 struct MapTilerURLBuilderTests {
     private static let baseURL: URL = "http://www.foo.com"
     private static let apiKey = "some_key"

UnitTests/Sources/RoomListFiltersStateTests.swift

@@ -9,6 +9,7 @@
 @testable import ElementX
 import Testing
 
+@MainActor
 final class RoomListFiltersStateTests {
     var appSettings: AppSettings
     var state: RoomListFiltersState

UnitTests/Sources/RoomSummaryTests.swift

@@ -11,6 +11,7 @@ import Foundation
 import MatrixRustSDKMocks
 import Testing
 
+@MainActor
 struct RoomSummaryTests {
     // swiftlint:disable:next large_tuple
     let roomDetails: (id: String, name: String, avatarURL: URL) = ("room_id", "Room Name", "mxc://hs.tld/room/avatar")

UnitTests/Sources/TestUtilities/WaitingConfirmation.swift

@@ -114,8 +114,10 @@ func waitForConfirmation<R>(_ comment: Comment? = nil,
                                   expectedCount: expectedCount,
                                   isolation: isolation,
                                   sourceLocation: sourceLocation) { confirmation in
-        let result = try body(.init(continuation: continuation,
-                                    expectedCount: expectedCount))
+        let result = try await runBody(on: isolation,
+                                       body,
+                                       with: .init(continuation: continuation,
+                                                   expectedCount: expectedCount))
         for await _ in stream {
             confirmation()
         }
@@ -123,6 +125,17 @@ func waitForConfirmation<R>(_ comment: Comment? = nil,
     }
 }
 
+/// Runs the body on the given actor, so that it can safely touch the caller's isolated state.
+///
+/// Swift Testing's `confirmation` runs its closure on the concurrent executor regardless of the
+/// isolation parameter, so without this hop a body that synchronously triggers main actor
+/// work (e.g. sending a view action) would crash on the runtime's executor check.
+private func runBody<R>(on isolation: isolated (any Actor)?,
+                        _ body: (WaitingConfirmation) throws -> R,
+                        with confirmation: WaitingConfirmation) rethrows -> R {
+    try body(confirmation)
+}
+
 /// Waits for a confirmation to be triggered an expected number of times within a synchronous body,
 /// with a timeout.
 ///
@@ -181,8 +194,10 @@ func waitForConfirmation<R>(_ comment: Comment? = nil,
                                   expectedCount: expectedCount,
                                   isolation: isolation,
                                   sourceLocation: sourceLocation) { confirmation in
-        let result = try body(.init(continuation: continuation,
-                                    expectedCount: expectedCount))
+        let result = try await runBody(on: isolation,
+                                       body,
+                                       with: .init(continuation: continuation,
+                                                   expectedCount: expectedCount))
         
         // The reason why I don't add to the task group directly the non timeout implementation
         // is that I do not want the body to be marked as @escaping and thus to be able to capture

UnitTests/Sources/TimelineStateTests.swift

@@ -10,6 +10,7 @@
 import OrderedCollections
 import Testing
 
+@MainActor
 struct TimelineStateTests {
     // MARK: - Read marker
     

UnitTests/Sources/UserPreferenceTests.swift

@@ -135,28 +135,28 @@ struct UserPreferenceTests {
     @Test
     func localOverRemoteValue() {
         let storage = VolatileUserDefaults()
-        @UserPreference(key: TestsKey.testKey, defaultValue: "", storage: storage) var preference
-        #expect(preference == "")
+        let preference = UserPreference(key: TestsKey.testKey, defaultValue: "", storage: storage)
+        #expect(preference.wrappedValue == "")
         
-        _preference.remoteValue = "remote"
-        #expect(preference == "remote")
+        preference.remoteValue = "remote"
+        #expect(preference.wrappedValue == "remote")
         
-        preference = "local"
-        #expect(preference == "local")
+        preference.wrappedValue = "local"
+        #expect(preference.wrappedValue == "local")
     }
     
     @Test
     func remoteOverLocalValue() {
         let storage = VolatileUserDefaults()
-        @UserPreference(key: TestsKey.testKey, defaultValue: "", storage: storage, mode: .remoteOverLocal) var preference
-        #expect(preference == "")
+        let preference = UserPreference(key: TestsKey.testKey, defaultValue: "", storage: storage, mode: .remoteOverLocal)
+        #expect(preference.wrappedValue == "")
         
-        _preference.remoteValue = "remote"
-        #expect(preference == "remote")
+        preference.remoteValue = "remote"
+        #expect(preference.wrappedValue == "remote")
         
-        preference = "local"
-        #expect(preference == "remote")
-        #expect(_preference.isLockedToRemote)
+        preference.wrappedValue = "local"
+        #expect(preference.wrappedValue == "remote")
+        #expect(preference.isLockedToRemote)
     }
 }