AI Development

2026 Swift 6.2 SwiftData : comment refactoriser progressivement la couche de données concurrente ?

2026 Swift 6.2 SwiftData : comment refactoriser progressivement la couche de données concurrente ?

Selon les notes de version d’Apple, la version initiale de Xcode 26 inclut Swift 6.2, tandis que Xcode 26.6 inclut Swift 6.3 : le projet doit donc d’abord être situé sur la bonne branche d’outillage, et non traité comme s’il s’agissait d’un changement imposé par « Xcode 18 » (notes de version de Xcode 26). Le choix gagnant, pour un ancien projet qui doit continuer à livrer, est une refactorisation concurrente de SwiftData dans Swift 6.2 par étapes : conserver une base de reproduction, fermer une seule chaîne d’écriture dans un @ModelActor, puis faire circuler un PersistentIdentifier ou un DTO Sendable. Il ne faut ni ajouter @MainActor à tout le projet, ni utiliser @unchecked Sendable pour faire disparaître les diagnostics.

Cet article s’adresse aux développeurs qui maintiennent ou livrent encore une branche Swift 6.2, aux architectes chargés de découper la couche SwiftData et aux responsables techniques qui doivent comparer plusieurs branches sur des environnements Mac séparés. Il convient particulièrement aux applications iOS et macOS qui enregistrent des médias, des documents de design ou des métadonnées audio sans pouvoir réécrire toute leur persistance en une seule itération.

Le faux succès de l’annotation globale

Le cas de départ est fréquent. Une équipe ajoute @MainActor à un service SwiftData, puis remonte l’annotation vers les modèles, les vues et plusieurs gestionnaires de tâches. Le compilateur devient silencieux. Pourtant, l’interface commence à attendre pendant un import vidéo, une génération de vignettes ou une synchronisation de documents. Le problème n’est pas résolu : il a été déplacé vers le chemin principal d’exécution.

Cette modification comporte au moins quatre coûts cachés :

  • les requêtes et sauvegardes qui n’ont pas besoin de l’interface reviennent sur l’acteur principal ;
  • les opérations de masse prolongent les périodes pendant lesquelles l’interface ne peut plus répondre ;
  • les appels de retour vers l’interface masquent parfois une attente circulaire entre tâche et acteur ;
  • le diagnostic devient moins précis, car une isolation trop large mélange propriété UI, contexte de données et orchestration métier.

Un avertissement @Sendable n’est pas automatiquement un interblocage. Une erreur d’isolation d’acteur n’est pas automatiquement une corruption de base. Une interface figée n’est pas automatiquement la preuve d’un verrou interne à SwiftData. Avant de parler de « deadlock SwiftData », il faut obtenir un échantillon de threads, une pile d’appels ou une trace reproductible.

Attention. @ModelActor fournit une frontière d’accès mutuellement exclusive aux propriétés du modèle, mais il ne transforme pas toute attente de l’interface en deadlock SwiftData. Une tâche bloquée sur une ressource externe, un appel synchrone ou une mauvaise durée de vie de Task peut produire un symptôme voisin.

La branche doit également être décrite correctement. Le mode de langage Swift 6 se choisit au niveau du projet et de la cible. Le contrôle de l’isolation par défaut dépend lui aussi de la configuration retenue ; il ne s’agit pas d’une activation universelle imposée à tous les anciens projets. La proposition consacrée au contrôle de l’acteur par défaut documente cette distinction (proposition Swift Evolution sur l’acteur par défaut).

Le point de départ : outillage et reproduction

Avant de modifier la couche de données, l’équipe doit enregistrer pour chaque cible :

  • la version exacte de Xcode utilisée pour compiler ;
  • le mode de langage Swift sélectionné ;
  • le niveau de vérification de la concurrence ;
  • l’acteur par défaut éventuel ;
  • la présence d’extensions, de modules ou de dépendances compilés avec une autre hypothèse d’isolation.

Cette fiche évite de confondre trois situations : une cible restée en Swift 5 avec des avertissements, une cible en Swift 6 avec des erreurs d’isolation, et une branche déjà testée avec une version ultérieure du compilateur. À la date du 9 septembre 2026, la frontière documentée est importante : Swift 6.2 correspond à la ligne initiale de Xcode 26, tandis que Xcode 26.6 contient Swift 6.3 (documentation officielle des versions Xcode). Une maintenance volontairement verrouillée sur Swift 6.2 ne doit donc pas être décrite comme une validation sur la version actuelle de Swift.

Ensuite, il faut conserver une reproduction minimale. Elle doit contenir une seule opération représentative : création d’un élément, modification d’un enregistrement ou import limité. Le test doit enregistrer :

  • le diagnostic de compilation complet ;
  • les identifiants des tâches et des acteurs lorsque cela est possible ;
  • les journaux avant et après save() ;
  • le comportement d’annulation ;
  • un échantillon de threads en cas de suspension prolongée ;
  • la branche ancienne pouvant être restaurée immédiatement.

La comparaison doit être observable. Une compilation réussie ne suffit pas. Il faut aussi vérifier que l’interface reste disponible, que la sauvegarde aboutit et que les données relues sont cohérentes.

La première chaîne à fermer

La meilleure première cible n’est pas forcément le fichier qui contient le plus d’erreurs. Il s’agit généralement de la chaîne qui combine écriture fréquente, appel depuis une tâche secondaire et retour vers l’interface. Un import de fichiers audio, la génération de vignettes vidéo ou l’enregistrement d’états d’un outil de design sont de bons candidats : ils exposent rapidement le partage involontaire de contexte et de modèles.

Le traçage doit rester limité à une seule route :

  1. l’interface déclenche l’action ;
  2. une tâche prépare des valeurs ;
  3. un service crée ou récupère son contexte ;
  4. le modèle est modifié ;
  5. la sauvegarde est exécutée ;
  6. l’interface reçoit un résultat d’affichage.

À chaque étape, l’équipe note le propriétaire du ModelContainer, du ModelContext, de l’état UI et de la tâche en arrière-plan. Le risque augmente lorsqu’un appel transporte directement un objet @Model, une fermeture capturant un contexte ou un ModelContext provenant d’un autre domaine d’isolation.

La documentation d’Apple rappelle que ModelContext est l’objet qui permet d’insérer, de rechercher, de modifier et de sauvegarder les modèles (documentation de ModelContext). Cette responsabilité ne doit pas être confondue avec celle de l’interface. Le conteneur peut être partagé comme dépendance de construction, mais le contexte utilisé pour une opération doit rester maîtrisé par la frontière qui exécute cette opération.

Le premier commit : une frontière @ModelActor

Le premier commit doit rester petit. Il crée un acteur chargé d’une responsabilité précise, par exemple l’écriture des métadonnées importées. L’appelant ne lui transmet pas un modèle provenant de son propre contexte. Il lui transmet des valeurs nécessaires à l’opération.

import SwiftData

struct ImportedAsset: Sendable {
    let externalID: String
    let title: String
    let duration: Double?
}

@ModelActor
actor AssetWriter {
    func insert(_ input: ImportedAsset) throws {
        let asset = Asset(
            externalID: input.externalID,
            title: input.title,
            duration: input.duration
        )

        modelContext.insert(asset)
        try modelContext.save()
    }
}

Le modèle exact dépend de l’application. Le principe ne dépend pas du nom de l’acteur : création, modification et sauvegarde restent dans le même contexte logique. La documentation publique d’Apple décrit le rôle de ModelActor et son accès au contexte associé (documentation de ModelActor).

La dépendance doit être injectée explicitement. Le code appelant conserve son rôle d’orchestrateur ; il ne récupère pas le contexte interne pour le réutiliser ailleurs.

struct ImportService {
    private let writer: AssetWriter

    init(container: ModelContainer) {
        self.writer = AssetWriter(modelContainer: container)
    }

    func run(input: ImportedAsset) async throws {
        try await writer.insert(input)
    }
}

Ce modèle n’est pas une enveloppe universelle. Une lecture destinée à une vue, une opération de migration et une écriture de masse peuvent nécessiter des politiques différentes. Le premier commit doit donc documenter ce qu’il possède et ce qu’il ne possède pas.

Les contrats d’entrée et de sortie

La question décisive est la suivante : que doit renvoyer l’acteur ? Dans la plupart des chaînes inter-acteurs, il ne doit pas renvoyer l’instance @Model elle-même. Cet objet est lié au contexte qui le gère. Le transmettre à l’interface ou à un autre acteur recrée précisément l’ambiguïté que la refactorisation cherche à éliminer.

Trois contrats sont plus sûrs :

  • un résultat immuable conforme à Sendable ;
  • un PersistentIdentifier permettant une nouvelle lecture dans le contexte du destinataire ;
  • un DTO conçu pour l’affichage, contenant uniquement les champs nécessaires.

PersistentIdentifier représente l’identité persistante d’un modèle et peut servir de référence transportable, sans transférer la propriété opérationnelle de l’objet entre contextes (documentation de PersistentIdentifier).

struct AssetSummary: Sendable {
    let id: PersistentIdentifier
    let title: String
    let duration: Double?
}

@ModelActor
actor AssetWriter {
    func insert(_ input: ImportedAsset) throws -> AssetSummary {
        let asset = Asset(
            externalID: input.externalID,
            title: input.title,
            duration: input.duration
        )

        modelContext.insert(asset)
        try modelContext.save()

        return AssetSummary(
            id: asset.persistentModelID,
            title: asset.title,
            duration: asset.duration
        )
    }
}

Le destinataire choisit ensuite sa stratégie. Une vue peut afficher le DTO reçu. Un autre service peut utiliser l’identifiant pour relire l’objet dans son propre contexte. Il ne doit pas prendre possession du contexte interne de AssetWriter.

Contrat entre domaines Avantage Limite Décision recommandée
Instance @Model Peu de code immédiat Risque de mauvais contexte et d’isolation implicite À éviter entre acteurs
PersistentIdentifier Référence compacte et nouvelle lecture contrôlée Nécessite une nouvelle récupération Adapté aux chaînes de lecture différée
DTO Sendable Interface claire et données limitées Il faut maintenir sa structure Adapté à l’UI, aux journaux et aux aperçus
@unchecked Sendable Fait taire certains diagnostics Ne garantit ni sécurité ni cohérence Réserver aux cas audités et temporaires

Les propositions Swift Evolution sur l’isolation des fonctions asynchrones précisent pourquoi le simple fait de rendre une fonction async ne suffit pas à rendre tous ses paramètres sûrs (proposition sur l’isolation des fonctions asynchrones). Le contrat doit donc être explicite à l’entrée comme à la sortie.

Le même jour : annulation et retours UI

Une opération d’import doit pouvoir être annulée avant une écriture, et son résultat doit rester structuré. Le service ne doit pas créer une tâche détachée sans propriétaire pour « revenir » vers l’interface. Il ne doit pas non plus utiliser un sémaphore, une file synchrone ou un appel bloquant pour contourner l’isolation.

func importAsset(
    _ input: ImportedAsset,
    writer: AssetWriter
) async throws -> AssetSummary {
    try Task.checkCancellation()
    let summary = try await writer.insert(input)
    try Task.checkCancellation()
    return summary
}

La couche UI reçoit ensuite AssetSummary, pas le ModelContext ni le modèle vivant. Elle peut décider d’actualiser une liste, d’afficher une erreur ou de laisser l’utilisateur poursuivre son montage. Dans un logiciel audio, cela évite qu’une sauvegarde de métadonnées bloque le contrôle visuel d’une piste. Dans un outil de design, cela sépare la création d’un aperçu de la sélection actuellement affichée.

Les erreurs doivent conserver leur origine. Une erreur de validation, une annulation et un échec de sauvegarde ne doivent pas être convertis en une seule valeur « impossible ». Cette distinction est utile pour les tests et pour le retour arrière.

Expérience de terrain. Si la nouvelle chaîne compile mais que l’interface reste suspendue, le diagnostic doit passer par un échantillon de threads et une pile d’appels. Sans cette preuve, il est prématuré d’accuser un verrou SwiftData ou d’ajouter une nouvelle annotation globale.

Le plan de migration par appels

La migration de toute la base n’est pas nécessaire pour valider le premier résultat. Un ancien projet peut migrer un seul target ou un seul module de données, à condition de définir la frontière et de conserver une voie de retour. Cette approche réduit le rayon d’une régression, notamment lorsque l’application possède plusieurs extensions ou plusieurs points d’entrée.

Le travail de la première semaine peut suivre les critères ci-dessous :

Phase de migration Modification autorisée Preuve attendue Retour arrière
Cible initiale Une chaîne d’écriture et son acteur Compilation, sauvegarde et résultat cohérent Interrupteur vers l’ancien service
Appels secondaires Un appelant observable à la fois Test de lecture, annulation et erreur Réactivation de l’appel précédent
Module voisin Même contrat DTO ou identifiant Tests du module et scénario utilisateur Module conservé sur l’ancienne implémentation
Dépendance non adaptée Compatibilité confinée à la bordure Audit du symbole de contournement Suppression du pont sans toucher aux modèles

À chaque commit, le responsable doit répondre à quatre questions : quelle donnée franchit la frontière, qui possède le contexte, quelle preuve confirme le changement, et quelle ligne permet de réactiver l’ancien chemin ? Une bascule de configuration ou une implémentation parallèle temporaire est préférable à une réécriture irréversible.

Les annotations de secours doivent être réexaminées une par une :

  • @unchecked Sendable reste limité à une valeur dont l’invariance est démontrée ;
  • @preconcurrency ne doit pas être répandu dans les modèles métier pour masquer une dépendance ancienne ;
  • Task.detached doit correspondre à une réelle indépendance de contexte et de durée de vie ;
  • une annotation @MainActor élargie doit être justifiée par une propriété UI, pas par la difficulté du diagnostic.

Si une bibliothèque tierce n’est pas encore adaptée, la compatibilité doit rester dans un module périphérique. Le code SwiftData central ne doit pas récupérer ses contournements par contamination progressive.

La validation avant élargissement

La dernière étape n’est pas une simple compilation. Le premier parcours migré doit être exécuté avec un jeu de données fixe et dans plusieurs conditions :

  • écritures successives ;
  • annulation pendant la préparation puis avant la sauvegarde ;
  • passage au premier plan et à l’arrière-plan ;
  • accès simultané depuis plusieurs fenêtres ;
  • accès concurrent d’une extension lorsqu’il existe ;
  • fermeture ou remplacement de la vue pendant l’opération ;
  • reprise après erreur de validation.

Les résultats à conserver sont les diagnostics de compilation, les erreurs de sauvegarde, les journaux d’annulation, les échantillons de suspension et les vérifications de cohérence des données. Une absence de crash ne suffit pas si une écriture disparaît ou si l’interface affiche un état obsolète.

La validation doit être réalisée dans l’outillage de livraison Swift 6.2 et dans l’outillage prévu pour la mise à niveau. Il faut aussi éliminer les explications locales : dossier de compilation dérivé, état du simulateur, cache d’un seul Mac ou données de test déjà présentes. Le nettoyage n’est pas une preuve de correction ; c’est seulement un moyen de vérifier que la reproduction ne dépend pas d’un artefact.

Seule la réussite de la première chaîne sur trois axes — compilation, activité et cohérence des données — justifie la copie du modèle vers un second module. Si la chaîne échoue, le retour doit viser le dernier contrat modifié, pas pousser davantage d’annotations.

Environnement Mac séparé et choix d’exécution

Une équipe qui maintient plusieurs branches peut aussi isoler les validations sur des environnements Mac distincts. Cela évite de mélanger les outils de Swift 6.2, les caches locaux et les réglages d’un projet plus récent. Il faut toutefois vérifier avant toute réservation que la version de Xcode nécessaire est disponible, que le mode de connexion correspond à la politique de l’équipe et que les données de test restent contrôlées.

La page d’aide de ProxyMac peut servir à vérifier les modalités d’accès et les limites de l’environnement avant d’y déplacer une reproduction. Une fois l’environnement confirmé, la console ProxyMac fournit le point de départ opérationnel pour lancer une session destinée à la comparaison de branches. Ces liens ne remplacent pas les contrôles techniques : ils servent à préparer un poste indépendant, pas à certifier la correction du code.

Option de validation Ce qu’elle isole Risque restant Quand la retenir
Mac de développement unique Peu de configuration Cache, simulateur et réglages locaux Pour un diagnostic initial très court
Second environnement Mac Branche, outils et état local séparés Disponibilité de la version Xcode requise Pour comparer deux branches
Environnement distant ProxyMac Poste indépendant et session dédiée Latence, accès aux fichiers et politique de données Pour une reproduction parallèle ou une équipe distribuée
Parc de postes internes Contrôle maximal des données Maintenance et installation des outils Pour des validations récurrentes et sensibles

La location n’est pas automatiquement le meilleur choix. Un projet qui nécessite une charge persistante et stable, des périphériques physiques, une carte de capture ou un accès local spécialisé peut préférer un Mac acheté et administré en interne. En revanche, pour une migration temporaire, une branche ancienne et une branche Swift 6.2 à comparer sans modifier le poste principal, un environnement Mac séparé limite les variables parasites.

Le choix final entre ancien chemin et Mac séparé

L’ancien chemin — annoter largement, conserver les modèles partagés et tester sur le seul poste du développeur — présente trois défauts concrets : il peut rendre l’interface responsable d’écritures lourdes, il mélange les caches et les versions d’outils, et il rend le retour arrière difficile lorsque plusieurs modules ont été modifiés simultanément. Il peut rester acceptable pour une reproduction locale courte, mais il devient fragile dès que plusieurs branches doivent être comparées.

Un Mac séparé ne corrige pas une mauvaise frontière @ModelActor et ne remplace pas les tests de cohérence. Il apporte autre chose : une session isolée pour vérifier que le comportement ne dépend pas du poste principal, du simulateur ou de l’état local du projet. Pour une équipe qui doit maintenir Swift 6.2 pendant une période limitée, louer un environnement Mac auprès de ProxyMac peut donc être plus pertinent que bouleverser le poste de production ou acheter une machine dédiée uniquement à cette migration. La décision reste conditionnelle : données sensibles, besoin de périphériques physiques et charge longue doivent être évalués avant la location.

La séquence la plus sûre reste inchangée : verrouiller l’outillage, conserver la reproduction, fermer une seule écriture, transporter un identifiant ou un DTO Sendable, puis étendre la migration après preuve. Un compilateur silencieux n’est pas encore une architecture concurrente fiable.

Développez et testez votre couche SwiftData sur un Mac distant

Avec ProxyMac, accédez à un environnement Mac distant pour compiler et tester vos évolutions Swift 6.2 dans des conditions maîtrisées.
Validez progressivement vos frontières entre acteurs, vos DTO Sendable et vos chaînes d’écriture sans interrompre le développement de votre équipe.