Migrer Swift 6 sur Mac distants dédiés :Portes CI de concurrence stricte et runbook d'isolation Actor

Les contrôles de concurrence stricte Swift 6 (-strict-concurrency=complete) évoluent avec la taille du code : 200 à 800 erreurs de compilation au premier passage est courant pour un projet iOS de taille moyenne. Les correctifs s'étalent sur des semaines ou des mois ; pendant cette période, le CI doit garantir :

• Versions mineures Xcode figées : les diagnostics d'isolation Actor changent de formulation selon les versions Xcode ; figer la version rend les sorties CI comparables.
• Pas de contention CPU des voisins : les compilations complètes en concurrence stricte durent 20 à 40 % de plus qu'une build debug typique ; les nœuds dédiés stabilisent la latence de queue P95.
• Espaces de noms DerivedData isolés : plusieurs PR exécutant des contrôles de concurrence ont besoin de caches incrémentaux séparés, sinon les résultats deviennent peu fiables.

Swift propose trois niveaux de drapeaux compilateur dans OTHER_SWIFT_FLAGS (réglages de build Xcode) ou swiftSettings dans Package.swift :

En pratique, migrez module par module : activez complete d'abord sur les modules feuilles, puis sur le cœur. SwiftPM .enableUpcomingFeature("StrictConcurrency") contrôle précisément le niveau par cible.

Environ 90 % des erreurs de compilation en migration relèvent de ces trois catégories ; les corriger efface la plupart des builds rouges :

① Accès inter-Actor à des types non Sendable

// ❌ Erreur : accès à l état @MainActor hors du contexte @MainActor
actor DataFetcher {
    func load() async {
        let result = await networkClient.fetch()
        // ❌ passing argument of non-sendable type 'UserModel' across actor boundary
        await MainActor.run { viewModel.update(result) }
    }
}

Correction : faire conformer UserModel à Sendable (les types valeur le satisfont souvent automatiquement), ou effectuer la conversion inter-frontière à l'intérieur de la frontière Actor.

② @MainActor manquant

Les sous-classes ViewController et ObservableObject de UIKit/SwiftUI tournaient implicitement sur le thread principal avant migration ; Swift 6 exige une annotation @MainActor explicite. Le bouton Corriger de Xcode peut traiter en lot, mais relisez chaque site pour ne pas tirer de la logique non UI sur le thread principal.

③ Accès concurrent aux variables globales

// ❌ En Swift 6, les globales doivent être Sendable ou nonisolated
var sharedCache: NSCache<NSString, AnyObject> = .init()

// ✅ nonisolated(unsafe) en transition
nonisolated(unsafe) var sharedCache: NSCache<NSString, AnyObject> = .init()

// ✅ Mieux : encapsuler dans un Actor avec API async
actor CacheStore {
    private let cache = NSCache<NSString, AnyObject>()
    func object(forKey key: String) -> AnyObject? { cache.object(forKey: key as NSString) }
}

Idée centrale pour les portes PR : exécuter les contrôles de concurrence dans un Job séparé des tests habituels. Les échecs ne polluent pas les rapports de test et vous pouvez appliquer des stratégies différentes pendant les correctifs (warn-only vs. block-merge). Sur NUKCLOUD : tarifs, puis commander — évitez les pics temporaires de pool à la minute pendant la migration.

Les fenêtres de correctif durent souvent des semaines : journalisez erreurs de concurrence, wall time de build complet et taille DerivedData, et liez-les aux changements de spec.

name: Swift 6 Concurrency Gate

on:
  pull_request:
    branches: [main, release/*]

jobs:
  concurrency-check:
    runs-on: self-hosted          # Runner Mac distant dédié NUKCLOUD
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v4

      - name: Sélectionner Xcode (version mineure figée)
        run: sudo xcode-select -s /Applications/Xcode_16.3.app

      - name: Restore DerivedData cache
        uses: actions/cache@v4
        with:
          path: ~/DerivedData/swift6-check
          key: swift6-${{ runner.name }}-${{ hashFiles('**/*.xcodeproj/project.pbxproj', '**/Package.resolved') }}
          restore-keys: swift6-${{ runner.name }}-

      - name: Build with strict concurrency (complete)
        run: |
          xcodebuild build \
            -project MyApp.xcodeproj \
            -scheme MyApp \
            -destination 'generic/platform=iOS Simulator' \
            -derivedDataPath ~/DerivedData/swift6-check \
            OTHER_SWIFT_FLAGS="-strict-concurrency=complete" \
            | xcbeautify --renderer github-actions

      - name: Upload build log on failure
        if: failure()
        uses: actions/upload-artifact@v4
        with:
          name: swift6-build-log-${{ github.sha }}
          path: ~/DerivedData/swift6-check/Logs/Build/

1. 01
   Instantané de base : sur un Mac distant dédié, lancez une build complète avec -strict-concurrency=minimal et enregistrez le nombre d'erreurs et le temps de compilation comme point de départ quantifié.
2. 02
   Modules feuilles en premier : dans le graphe SwiftPM, choisissez les cibles sans dépendants aval et activez complete une par une. Soumettez une PR distincte par cible pour des diffs vérifiables.
3. 03
   Stratégie de branche CI : sur une branche longue feature/swift6-migration, exécutez les Jobs de concurrence en warn-only (continue-on-error: true) sans bloquer les fusions PR quotidiennes. Passez une cible en block-merge uniquement quand elle atteint 0 erreur.
4. 04
   Figez la version Xcode : inscrivez la version xcode-select dans le runbook et le README pour que les développeurs Mac locaux et les nœuds CI partagent la même version mineure et évitent le bruit « passe en local, échoue en CI ».
5. 05
   Tableau de bord des tendances d'erreurs : journalisez le nombre d'erreurs Swift 6 par exécution CI dans des logs structurés ou des métriques de build ; suivez la migration par courbes et fixez des objectifs hebdomadaires d'équipe pour réduire X erreurs.
6. 06
   Acceptation de porte complète : après 0 erreur sur tous les modules, activez Require swift6-concurrency-check to pass sur la protection de branche main et définissez SWIFT_VERSION = 6 sur toutes les cibles pour basculer en mode langage Swift 6.

La migration Swift 6 exige à la fois une itération locale rapide et une validation CI complète fiable ; les besoins de nœud diffèrent :