Apple a officiellement lancé Swift 6.2, la prochaine étape majeure dans l'évolution de son puissant langage de programmation. Cette version introduit de nouvelles fonctionnalités, améliore la gestion de la concurrence, renforce l'interopérabilité entre les langages et optimise les performances à grande échelle. Cette mise à jour apporte également des changements significatifs qui auront une incidence sur la manière dont les développeurs structureront et écriront leur code à l'avenir, qu'ils créent des applications dans l'écosystème Apple ou qu'ils intègrent Swift dans des environnements côté serveur et multiplateformes.Swift est un langage de programmation compilé, polyvalent, multi-paradigme et de haut niveau, créé par Chris Lattner en 2010 pour Apple Inc. et maintenu par la communauté open source. Swift compile en code machine et utilise un compilateur basé sur LLVM. Le langage a été lancé pour la première fois en juin 2014 et la chaîne d'outils Swift est intégrée à Xcode depuis la version 6 de Xcode, sortie en septembre 2014.
Swift 6.2 introduit des mises à jour axées sur la programmation concurrente, les performances et l'amélioration des outils de développement. Cette version rend la programmation concurrente plus accessible en utilisant par défaut un fonctionnement à thread unique et en proposant des fonctions asynchrones intuitives, ce qui permet aux développeurs d'écrire du code concurrent sécurisé avec moins de code standard.
Parallèlement, Swift 6.2 optimise les performances sans sacrifier la sécurité, permettant ainsi un code de bas niveau avec une exécution prévisible et une surcharge minimale.
Suite à ces améliorations du langage, l'extension officielle Swift pour Visual Studio Code a été vérifiée et est désormais distribuée par Swift.org. Afin d'aider les équipes à effectuer les mises à niveau, de nouveaux outils de migration permettent aux projets d'adopter les fonctionnalités du langage à venir.
L'expérience des développeurs est encore améliorée grâce à des temps de compilation nettement plus rapides, en particulier pour les projets utilisant des API basées sur des macros. Les développeurs bénéficient d'un débogage amélioré du code concurrent dans LLDB et de nouvelles options pour gérer les avertissements du compilateur au niveau du groupe de diagnostic.
S'appuyant sur les améliorations apportées à l'écosystème, les mises à jour de la bibliothèque Swift 6.2 comprennent un nouveau package Subprocess, des améliorations de la bibliothèque Foundation et de nouvelles API destinées à prendre en charge des modèles de codage plus sûrs.
Enfin, Swift 6.2 ajoute également la prise en charge de WebAssembly, permettant aux applications Swift clientes et serveurs de cibler Wasm et de se déployer sur des navigateurs ou d'autres environnements compatibles.
Concurrence accessible
Swift 6.2 facilite la programmation concurrente grâce à une série de modifications visant à réduire les codes standard et à permettre d'écrire plus naturellement du code concurrent sécurisé :
- Monothread par défaut : les développeurs peuvent exécuter leur code sur le thread principal sans annotations @MainActor explicites à l'aide de la nouvelle option permettant d'isoler le code vers l'acteur principal par défaut. Cette option est idéale pour les scripts, le code d'interface utilisateur et d'autres cibles exécutables.
- Fonctions asynchrones intuitives : écrire du code asynchrone sans accès simultané à un état modifiable. Auparavant, les méthodes asynchrones non isolées basculaient toujours vers l'exécuteur global qui gère le pool de threads simultanés, ce qui rendait difficile l'écriture de méthodes asynchrones pour les types de classes sans erreurs de sécurité liées aux conflits de données. Dans Swift 6.2, il est possible de migrer vers une fonctionnalité à venir où les fonctions asynchrones s'exécutent dans le contexte d'exécution de l'appelant, même lorsqu'elles sont appelées sur l'acteur principal.
- Activer la concurrence avec @concurrent : introduire du code qui s'exécute simultanément à l'aide du nouvel attribut @concurrent. Cela permet de préciser clairement quand on souhaite que le code reste sérialisé sur l'acteur et quand il peut s'exécuter en parallèle.
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | // In '-default-isolation MainActor' mode struct Image { // The image cache is safe because it's protected // by the main actor. static var cachedImage: [URL: Image] = [:] static func create(from url: URL) async throws -> Image { if let image = cachedImage[url] { return image } let image = try await fetchImage(at: url) cachedImage[url] = image return image } // Fetch the data from the given URL and decode it. // This is performed on the concurrent thread pool to // keep the main actor free while decoding large images. @concurrent static func fetchImage(at url: URL) async throws -> Image { let (data, _) = try await URLSession.shared.data(from: url) return await decode(data: data) } } |
Ensemble, ces améliorations permettent d'écrire du code sans conflit d'accès aux données avec moins de surcharge d'annotation, offrent un comportement plus prévisible pour le code asynchrone, tout en permettant d'introduire la concurrence lorsque cela est nécessaire.
Programmation de systèmes sécurisés
Swift 6.2 comprend des fonctionnalités conçues pour optimiser les performances sans compromettre la sécurité. Ces fonctionnalités aident à écrire du code sécurisé de bas niveau avec des performances prévisibles et une surcharge minimale.
InlineArray est un nouveau tableau de taille fixe avec stockage en ligne pour les éléments, qui peuvent être stockés dans la pile ou directement dans d'autres types sans allocation supplémentaire dans le tas. Le développeur peut introduire un tableau en ligne en écrivant la taille entre crochets avant l'élément, ou en utilisant la syntaxe abrégée :
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 8 | struct Game { // Shorthand for InlineArray<40, Sprite> var bricks: [40 of Sprite] init(_ brickSprite: Sprite) { bricks = .init(repeating: brickSprite) } } |
Le nouveau type Span offre un accès direct et sécurisé à la mémoire contiguë. Span garantit la sécurité de la mémoire en s'assurant que celle-ci reste valide pendant son utilisation. Ces garanties sont vérifiées lors de la compilation, sans surcoût d'exécution, et éliminent les problèmes de sécurité de la mémoire inhérents aux pointeurs, tels que les bogues de type « use-after-free ».
Swift 6.2 améliore ses capacités pour les projets de bas niveau et critiques en matière de sécurité au-delà des nouvelles API :
- Swift embarqué : Swift embarqué inclut désormais l'ensemble des API String de Swift, tous les types pour les protocoles contraints par classe, ainsi que les nouveaux types InlineArray et Span.
- Interopérabilité C++ sécurisée : les projets qui combinent Swift et C++ peuvent tirer parti des abstractions sécurisées de Swift, telles que Span pour les API C++, grâce à des annotations d'en-tête.
- Sécurité mémoire stricte en option : Swift assure la sécurité mémoire depuis sa création, tout en permettant l'utilisation de constructions non sécurisées telles que les pointeurs non sécurisés lorsque cela est nécessaire, par exemple lors de l'utilisation d'une API C qui accepte les pointeurs. Swift 6.2 introduit la sécurité mémoire stricte optionnelle, qui signale les utilisations de constructions non sécurisées afin que le développeur puisse les remplacer par des alternatives sécurisées ou les reconnaître explicitement dans le code source. Il s'agit d'une option facultative, car la majorité des projets n'ont pas besoin d'un tel niveau de sécurité. La sécurité mémoire stricte est réservée aux projets ayant les exigences de sécurité les plus élevées.
Workflows rationalisés
Au-delà des améliorations du langage, Swift 6.2 fluidifie le cycle quotidien d'itération consistant à éditer, compiler et déboguer le code.
Extension Swift pour VS Code
L'extension Swift pour VS Code est désormais officiellement vérifiée et distribuée par Swift.org. La dernière version de l'extension comprend :
- Indexation en arrière-plan par défaut : écrire du code grâce à des fonctionnalités d'édition rapides et toujours à jour, telles que le saut vers la définition et la complétion de code.
- Débogage LLDB intégré : parcourir le code Swift, définir des points d'arrêt et inspecter l'état à l'aide de LLDB directement dans VS Code.
- Panneau de projet Swift : naviguer parmi les cibles, les dépendances et les tâches d'un projet Swift dans la vue Explorateur.
- Aperçu DocC en live : prévisualiser la documentation rendue côte à côte avec le code, la mise à jour se fait en live pendant la saisie.
Ces améliorations apportées au flux de travail facilitent le travail sur les projets Swift dans l'environnement de votre choix grâce à des outils de premier ordre.
Contrôle précis des avertissements
Swift 6.2 améliore la gestion des avertissements du compilateur en permettant un contrôle au niveau des groupes de diagnostics. Un groupe de diagnostics est une catégorie d'avertissements identifiée par un nom. Il est possible de spécifier le comportement souhaité des avertissements dans un groupe de diagnostics dans un manifeste de package Swift à l'aide de la méthode treatWarning sur SwiftSetting, ou de promouvoir tous les avertissements en erreurs à l'aide de la méthode treatAllWarnings. Par exemple, il est possible de promouvoir tous les avertissements en erreurs, à l'exception des avertissements concernant l'utilisation d'API obsolètes :
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 | .target( name: "MyLibrary", swiftSettings: [ .treatAllWarnings(as: .error), .treatWarning("DeprecatedDeclaration", as: .warning), ] ) |
Performances de compilation des macros
Swift 6.2 améliore considérablement les temps de compilation des projets qui utilisent des API basées sur des macros. Auparavant, le système de compilation devait d'abord récupérer et compiler le paquet swift-syntax à partir du code source avant de compiler le projet macro, ce qui allongeait considérablement les temps de compilation, en particulier dans les environnements CI. SwiftPM prend désormais en charge les dépendances swift-syntax précompilées, éliminant ainsi complètement une étape de compilation coûteuse.
Débogage asynchrone amélioré
Swift 6.2 facilite considérablement le suivi de ce qui se passe dans le code concurrent lors du débogage avec LLDB : Exécution asynchrone robuste : exécution fiable des fonctions asynchrones dans LLDB, même lorsque l'appel asynchrone nécessite un changement de thread.
- Exécution de la commande « step-in » dans les fonctions asynchrones : exécution fiable de la commande « step-in » dans les fonctions asynchrones, même lorsque l'appel asynchrone nécessite un changement de thread.
- Affichage du contexte de la tâche : visualiser la tâche sur laquelle s'exécute un morceau de code lorsqu'il est arrêté à un point d'arrêt et lors de l'affichage de la trace de retour pour le thread actuel.
- Tâches nommées : attribution de noms lisibles par l'utilisateur lors de la création de tâches, qui apparaissent dans le contexte de la tâche dans les outils de débogage et de profilage.
Migration vers les fonctionnalités à venir
Swift 6.2 comprend des outils de migration pour permettre l'adoption des fonctionnalités à venir du langage :
- Identifier les incompatibilités de source : identifier les modèles de code qui ne compileront plus ou modifieront leur comportement lorsque la fonctionnalité à venir sera activée, grâce aux avertissements générés par les outils de migration.
- Automatiser les modifications de code : appliquer des correctifs pour mettre à jour le code afin de préserver son comportement existant.
Cela simplifie le processus d'activation des fonctionnalités à venir en éliminant la tâche fastidieuse des modifications manuelles du code.
[B]Mises à jour des bibliothèques...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.