DevOps / CI/CD

Comment corriger les erreurs de propriété de Swift 6.2 ? Guide de secours pour les projets existants (2026)

Comment corriger les erreurs de propriété de Swift 6.2 ? Guide de secours pour les projets existants (2026)

La proposition SE-0377 définit deux modificateurs de propriété des paramètres : borrowing et consuming. Pour corriger une erreur attribuée à Swift 6.2, commencez par relever la version réelle du compilateur, le mode de langage et le diagnostic complet ; choisissez ensuite une correction selon la capacité du type à être copié, les usages ultérieurs de la valeur et le contrat de l’API. Ne transformez pas chaque paramètre en consuming et ne réécrivez pas la gestion mémoire de tout le projet.

Cet article s’adresse aux responsables techniques qui mettent à niveau la chaîne Swift et veulent maîtriser les régressions de compilation. Il concerne aussi les développeurs confrontés à borrowing, consuming, Copyable ou à un diagnostic du type « Cannot consume value ». Les architectes de bibliothèques et d’interfaces génériques y trouveront des repères pour évaluer la compatibilité des changements.

Écarter d’abord les erreurs de configuration

Un échec apparu après une mise à niveau n’est pas automatiquement une erreur de propriété. Un projet peut combiner plusieurs compilateurs, modes de langage, réglages de cible et dépendances compilées avec des options différentes. Un diagnostic de contrainte générique peut également ressembler à une erreur de consommation, alors que le problème se situe dans la déclaration d’un protocole ou d’un conteneur.

Avant de modifier le code, consignez les éléments qui permettent de reproduire l’échec :

  • La version de Xcode utilisée et la sortie de swiftc --version sur la machine concernée. La documentation du compilateur Swift décrit les outils et les informations de version à relever.
  • Le mode de langage Swift appliqué à la cible, ainsi que les réglages de construction pertinents. Les notes de version Xcode servent à vérifier les informations propres à l’outil ; la référence des réglages de construction aide à contrôler ceux du projet.
  • Le texte intégral du diagnostic, le fichier concerné, la cible et le chemin de compilation qui l’a déclenché. Une capture tronquée masque souvent la note qui désigne la déclaration ou l’usage en cause.
  • La commande ou l’action de construction minimale qui reproduit le problème, en distinguant si nécessaire une application, un module, un test ou une dépendance.
Observation Cause à examiner en priorité Première action
Le diagnostic nomme une valeur consommée ou réutilisée Cycle de vie de la valeur dans le chemin concerné Repérer chaque usage avant et après l’opération signalée
Le message concerne une contrainte ou un paramètre générique Contrat de type, protocole ou contrainte implicite Remonter de l’appel vers la déclaration générique
Un module échoue alors que les autres compilent Réglage de cible, dépendance ou mode de langage divergent Comparer les paramètres effectifs des cibles concernées
L’échec suit une modification d’API Contrat de propriété ou compatibilité des appelants Vérifier les sites d’appel et la surface publique

Cette distinction évite une fausse piste coûteuse : ajouter des annotations de propriété à un appel ne réparera ni une version de compilateur non prévue par la dépendance, ni une contrainte absente dans une déclaration générique. Dans un dépôt important, reproduisez d’abord un seul échec sur une cible isolée. Si le résultat varie selon l’environnement, examinez les réglages avant de refactoriser.

« Cannot consume value » : retrouver le premier usage incompatible

Un diagnostic de valeur consommée ne se corrige pas en ajoutant mécaniquement une annotation. Il faut comprendre quel usage transfère la valeur et si le programme en a encore besoin ensuite. Le chemin à examiner peut traverser une branche conditionnelle, une fermeture, un appel intermédiaire ou un retour anticipé ; le message affiché sur une ligne ne décrit pas nécessairement tout ce chemin.

Dans un cas fréquent, une fonction reçoit une valeur, la transmet à une opération qui en prend possession, puis le code essaie de la réutiliser. La correction dépend alors de l’intention :

  • Transfert définitif : si l’appelant n’a réellement plus besoin de la valeur après l’appel, un contrat consuming peut exprimer cette intention. Vérifiez néanmoins que tous les chemins respectent ce transfert.
  • Utilisation sans transfert : si la fonction doit seulement examiner la valeur et que l’appelant doit la conserver, un emprunt borrowing correspond mieux au besoin. Il ne faut pas le choisir uniquement parce qu’il fait disparaître le message.
  • Nouvel usage indépendant : si le type est copiable et si une copie est sémantiquement acceptable, une copie explicite peut convenir. Elle n’est pas une solution neutre pour tous les types, ni une garantie de coût négligeable dans tous les contextes.
  • Logique de branchement ambiguë : si seule une branche consomme la valeur, examinez les usages de l’autre branche et les retours. Réorganiser le flux peut être plus juste que modifier le contrat de la fonction.

Il faut donc écrire, pour le chemin fautif, une petite chronologie : création ou réception de la valeur, premier usage qui peut en transférer la propriété, puis usages qui suivent. Cette carte suffit souvent à séparer un transfert voulu d’une réutilisation accidentelle. Le diagnostic « Cannot consume value » indique un conflit à analyser ; il ne dicte pas à lui seul la réparation.

Un correctif n’est valide que s’il conserve le comportement attendu sur les chemins d’erreur et les sorties anticipées. Un projet peut compiler après un changement de propriété tout en ayant modifié la durée de vie ou la disponibilité d’une ressource.

Contrats borrowing et consuming : suivre l’intention de l’API

La proposition SE-0377 sur la propriété des paramètres formalise la différence entre emprunter une valeur pendant l’appel et en prendre possession. La question utile n’est pas « quelle annotation fait taire le compilateur ? », mais « l’appelant doit-il pouvoir continuer à utiliser cette valeur après l’appel ? ».

borrowing exprime une utilisation qui ne prend pas possession de l’argument. C’est cohérent pour une fonction qui consulte une valeur sans la consommer et lorsque l’appelant doit rester libre de poursuivre son propre travail avec celle-ci. consuming exprime un transfert : le contrat autorise la fonction appelée à prendre possession de l’argument. Ce choix doit suivre la responsabilité réelle de la fonction et le comportement souhaité au site d’appel.

Besoin du code appelé Contrat à examiner Risque d’un choix fait uniquement pour compiler
Lire ou inspecter la valeur sans en prendre possession borrowing Modifier le contrat d’appel sans nécessité et compliquer l’évolution de l’API
Prendre définitivement possession de la valeur consuming Rendre incompatibles des usages ultérieurs attendus par les appelants
Laisser l’appelant réutiliser une valeur copiable Paramètre et type adaptés à cet usage Introduire une copie dont la sémantique n’a pas été examinée
Accepter des types avec des propriétés de copie différentes Interface générique explicitement conçue pour ce besoin Imposer une contrainte inadaptée à certains appelants

Pour une fonction interne, un changement peut être local et vérifiable en remontant ses appels. Pour une fonction publique ou partagée entre modules, il faut inspecter les appelants, les surcharges, les tests et les dépendances qui utilisent cette interface. Changer le contrat uniquement pour résoudre un diagnostic isolé peut entraîner une série de corrections dans des modules éloignés, voire une rupture de compatibilité source ou binaire selon le contexte de distribution et les réglages de construction. Les réglages de construction sont donc à vérifier avec la surface réellement publiée, plutôt que de supposer que toutes les cibles partagent les mêmes conditions.

Le bon arbitrage compare les avantages et les inconvénients du changement. Un contrat explicite clarifie le transfert voulu et peut mieux représenter les besoins d’un type non copiable. En contrepartie, modifier une interface largement utilisée agrandit la surface de migration et peut obliger les appelants à revoir leur propre cycle de vie. Si la fonction ne doit pas prendre possession, modifier sa signature pour apaiser un seul site d’appel masque le problème au lieu de le résoudre.

Contraintes Copyable : distinguer le type de l’interface

Une erreur mentionnant Copyable peut venir du type concret, mais aussi d’une abstraction qui exige implicitement une capacité de copie. Il faut remonter les déclarations dans l’ordre : type concret, paramètre générique, protocole, puis conteneur ou fonction intermédiaire. La proposition SE-0390 sur les structures et énumérations non copiables décrit le cadre des types non copiables ; SE-0427 sur les génériques non copiables précise comment les génériques peuvent exprimer ces cas.

Un type peut être intentionnellement non copiable parce que le copier contredirait sa sémantique ou sa gestion de ressource. Dans ce cas, ajouter Copyable pour satisfaire une abstraction n’est pas une réparation : cela change le modèle du type. À l’inverse, si le type concret est copiable, mais qu’une interface générique, une extension ou un protocole formule une exigence trop large, le défaut peut se trouver dans l’abstraction. La documentation Swift sur les génériques aide à lire la relation entre paramètres de type et contraintes.

Lorsqu’un diagnostic apparaît dans un conteneur standard ou une API de bibliothèque, vérifiez aussi les primitives concernées. SE-0437 décrit des éléments non copiables de la bibliothèque standard ; sa portée ne signifie pas que tous les conteneurs acceptent n’importe quel type, ni que toute contrainte peut être supprimée. La réparation dépend du contrat précis du conteneur et des opérations qu’il doit fournir.

Pour répondre à la question du périmètre : un projet n’a pas à convertir toutes ses valeurs en types non copiables parce qu’un diagnostic de propriété est apparu. La conception non copiable est appropriée quand la sémantique du type l’exige. Si le conflit provient d’une interface trop restrictive, il faut corriger ou adapter cette interface, pas remodeler le projet entier. Le guide de migration Swift 6 sur la sécurité des accès concurrents traite d’un autre ensemble de vérifications : il ne faut pas confondre un diagnostic de concurrence avec un diagnostic de propriété.

Migration par module : réduire le rayon de régression

Dans un grand projet, les mêmes messages peuvent cacher plusieurs causes. Une équipe qui remplace partout un modificateur ou une contrainte peut obtenir une compilation locale tout en élargissant la migration aux bibliothèques, aux tests et au code généré. Une méthode plus sûre consiste à regrouper les échecs par cause probable, puis à valider un exemple représentatif avant d’étendre le changement.

Le tableau suivant sert à choisir le premier périmètre de travail, sans supposer que tous les modules utilisent les mêmes options :

Périmètre observé Vérification prioritaire Validation avant extension
Un appel et quelques usages proches Cycle de vie, branchements et fermeture Compiler la cible minimale et vérifier les usages ultérieurs
Plusieurs modules partagés Signature publique et appelants transversaux Construire chaque module consommateur concerné
Dépendance ou paquet Swift Version, mode de langage et options propres au paquet Reproduire avec la dépendance dans ses conditions de construction réelles
Code généré Source du générateur et règles de régénération Corriger la source génératrice, puis régénérer et reconstruire
Échecs mêlant types et concurrence Catégories de diagnostics séparées Traiter chaque famille indépendamment et relancer les tests ciblés

Pour répondre à une série d’erreurs sans transformer le dépôt entier, suivez une séquence reproductible :

  • Conservez un diagnostic représentatif complet pour chaque famille, avec la cible et les réglages utiles.
  • Choisissez un appel réel qui reproduit la cause supposée ; vérifiez ses branches et ses usages ultérieurs.
  • Modifiez le plus petit élément responsable : le site d’appel, la signature interne ou la contrainte générique, selon le cas établi.
  • Recompilez la cible affectée, puis les modules qui exposent ou consomment l’interface modifiée.
  • Lancez les tests des chemins normaux et des chemins d’erreur ; vérifiez aussi les fermetures qui capturent les valeurs concernées.
  • Étendez le correctif aux diagnostics de même cause, en conservant des changements séparés qui peuvent être examinés ou annulés indépendamment.
  • Si la correction échoue dans une autre cible, comparez ses réglages et son mode de langage avant de généraliser le changement.

Cette démarche évite deux coûts discrets. D’abord, un correctif global peut compliquer l’identification de la modification qui a réellement résolu l’échec. Ensuite, un changement d’interface peut déplacer le problème vers les consommateurs sans que le module d’origine le révèle. Pour une équipe, des validations de construction et de tests à chaque étape facilitent aussi le retour à un état connu si une régression comportementale apparaît.

Liste de contrôle avant intégration

Avant de fusionner une modification de propriété, vérifiez les points suivants :

  • [ ] La version de Xcode et celle du compilateur Swift ont été relevées pour la cible qui échoue.
  • [ ] Le mode de langage et les réglages de construction applicables ont été confirmés.
  • [ ] Le diagnostic complet a été classé : consommation, contrat de paramètre, contrainte générique, concurrence ou incompatibilité d’outil.
  • [ ] Le cycle de vie de la valeur est compris sur les branches normales, les sorties anticipées et les chemins d’erreur.
  • [ ] Le choix entre emprunt, transfert et copie correspond à la sémantique du type, et non à une substitution automatique.
  • [ ] Les appelants d’une API partagée et les modules dépendants ont été identifiés.
  • [ ] Les paquets, cibles de test et sources générées ont été contrôlés avec leurs options propres.
  • [ ] La compilation et les tests ciblés ont été exécutés après chaque groupe cohérent de changements.
  • [ ] Le commit peut être annulé sans réintroduire silencieusement un changement d’API non vérifié.

Les exemples d’usage, les notes de conception et les validations automatisées doivent préciser l’environnement de compilation où la correction a été constatée. Les pages de référence de Xcode peuvent aider à vérifier les informations de l’outil, mais elles ne remplacent pas la reproduction sur les cibles du dépôt. Il ne faut pas présenter une économie de mémoire, une amélioration de vitesse ou un remplacement d’ARC comme une garantie générale : ces résultats nécessitent une mesure propre au code et au scénario concernés.

Pour une erreur de type, louer une machine ne constitue pas le correctif. Le choix se pose plutôt lorsque l’équipe doit reproduire une construction iOS dans un environnement Mac distinct, sans acheter immédiatement une machine dédiée. Un poste déjà disponible évite une location récurrente, mais peut être difficile à partager ou à isoler ; un environnement de construction mutualisé peut simplifier certains essais, mais ajoute des questions de configuration, d’accès et de reproductibilité. Une location Mac via ProxyMac peut offrir un environnement séparé pour valider une configuration, à condition de vérifier que l’accès et les outils proposés conviennent au projet. Les détails pratiques peuvent être examinés dans la page d’aide de ProxyMac. Cette option facilite des tests d’environnement ; la décision entre borrowing, consuming et Copyable, elle, reste à prendre dans le code et selon le contrat réel de l’API.

Validez votre migration Swift 6.2 sur un Mac dédié

Avec ProxyMac, compilez et testez vos modules sur un Mac mini M4 physique dédié, dans un environnement macOS complet.
Accédez à distance par SSH ou VNC pour reproduire les diagnostics de propriété et vérifier vos corrections.