Swift 5.9 release blog post

_posts/2023-08-29-swift-5.9-released.md

@@ -0,0 +1,209 @@
+---
+layout: post
+published: true
+date: 2023-08-29 15:00:00
+title: Swift 5.9 Released!
+author: [alexandersandberg]
+---
+
+Swift 5.9 is now officially released! 🎉 Swift 5.9 is the foundation for many long-awaited features that give library authors more expressive power, including a new macro system and parameter packs, improve the debugging experience through enhanced crash logs and new features in LLDB’s expression evaluator, Swift Package Manager support for a new `package` access modifier and macro targets, bi-directional interoperability with C++, Windows platform improvements, and more.
+
+Thank you to everyone in the Swift community who made this release possible. Your Swift Forums discussions, bug reports, pull requests, educational content, and other contributions are always appreciated!
+
+<!-- TODO: Link to Swift 5.9 showcase resource -->
+
+[The Swift Programming Language](https://docs.swift.org/swift-book/documentation/the-swift-programming-language/) book has been updated for Swift 5.9 and is now published with DocC. This is the official Swift guide and a great entry point for those new to Swift. The Swift community also maintains a number of [translations](/documentation/#translations).
+
+## Language and Standard Library
+
+Swift 5.9 tackles three long-desired features that allow you to express things you couldn’t easily do before.
+
+Swift now supports [macros](https://github.com/apple/swift-evolution/blob/main/visions/macros.md), which allow developers to reduce repetitive boilerplate and create new language features that can be distributed as a Swift package. Using a macro is easy and natural; macros can either be called with the function-like freestanding `#macroName` syntax or attached to declarations with an `@MacroName` attribute, so they work just like built-in language features but can’t be mistaken for normal code. Implementing a macro uses a powerful and flexible approach: Macros are implemented by writing Swift functions that use the SwiftSyntax library to generate code to insert into the source file. Macros make it easy for your library’s users to adopt powerful capabilities that adapt to the code they’re used in, like [the new `Observation` module](https://github.com/apple/swift-evolution/blob/main/proposals/0395-observability.md), which allows Swift classes to automatically notify other code when their properties change.
+
+Swift also has new features to help developers fine-tune memory management behavior in performance-critical code. The [`consume` operator](https://github.com/apple/swift-evolution/blob/main/proposals/0366-move-function.md) tells Swift to deinitialize a variable and transfer its contents without copying it. The [`consuming` and `borrowing` parameter modifiers](https://github.com/apple/swift-evolution/blob/main/proposals/0377-parameter-ownership-modifiers.md) provide hints that Swift can use to eliminate unnecessary copying and reference-counting operations when passing a parameter. Finally, [noncopyable structs and enums](https://github.com/apple/swift-evolution/blob/main/proposals/0390-noncopyable-structs-and-enums.md) allow you to create types which, like a class, represent a specific resource that can’t be meaningfully copied when it’s assigned, but like a struct or enum, do not need to be reference-counted because only one storage location can own the instance at a time.
+
+The last of these major features is [parameter packs](https://github.com/apple/swift-evolution/blob/main/proposals/0393-parameter-packs.md). These let you write generic types and functions which work over not just any type, but any _number_ of types. For example, this `all(_:)` function lets you check whether any number of `Optional` values are `nil`, even if the optionals wrap different types:
+
+```swift
+func all<each Wrapped>(_ optional: repeat (each Wrapped)?) -> (repeat each Wrapped)? {
+    // Implementation provided below
+}
+
+let optionalInt: Int? = 1
+let optionalDouble: Double? = 2.5
+let optionalString: String? = nil
+
+if let (int, double, string) = all(optionalInt, optionalDouble, optionalString) {
+    print(int, double, string)
+}
+else {
+    print("got a nil")
+}
+```
+
+<details markdown="1" class="download">
+  <summary>Implementation of <code>all</code></summary>
+
+```swift
+/// Takes any number of `Optional` arguments and returns `nil` if any of them
+/// are `nil`, or a tuple of their values if all of them are non-`nil`.
+func all<each Wrapped>(_ optional: repeat (each Wrapped)?) -> (repeat each Wrapped)? {
+  /// Accumulates the results from the `checkNilness(of:)` helper function.
+  var anyAreNil = false
+
+  // Check if any of the arguments in `each optional` is nil by running this
+  // `checkNilness(of:)` function on each argument.
+  func checkNilness<OneWrapped>(of oneOptional: OneWrapped?) {
+      if oneOptional == nil {
+          anyAreNil = true
+      }
+  }
+  repeat checkNilness(of: each optional)
+
+  // Did `checkNilness(of:)` find any nils? If so, return nil early.
+  if anyAreNil {
+      return nil
+  }
+
+  // Otherwise, we can safely force-unwrap all of the arguments and form a tuple
+  // from the unwrapped values.
+  return (repeat (each optional)!)
+}
+```
+
+</details>
+
+What’s more, these features are all usable today in Swift 5.9, but they are not finished evolving. Each one is too large to fully implement in a single release; we’re excited about what you can already do with them in Swift 5.9, but we’re even more excited to have laid the foundations for better things to come.
+
+In addition to these major features, Swift 5.9 also includes many smaller refinements to the language. The one developers will probably use most often is [`if` and `switch` expressions](https://github.com/apple/swift-evolution/blob/main/proposals/0380-if-switch-expressions.md), which lets you assign the result of a single-expression `if` or `switch` statement to a variable:
+
+```swift
+statusBar.text = if !hasConnection { "Disconnected" }
+                 else if let error = lastError { error.localizedDescription }
+                 else { "Ready" }
+```
+
+Swift 5.9 also adds a [new `package` access level](https://github.com/apple/swift-evolution/blob/main/proposals/0386-package-access-modifier.md) that lets other modules in the same package access APIs, but hides them from code outside the package. It’s great for splitting up large modules into several smaller ones without exposing internals to the package’s clients.
+
+Developers using Swift Concurrency may appreciate the [more convenient `DiscardingTaskGroup` types](https://github.com/apple/swift-evolution/blob/main/proposals/0381-task-group-discard-results.md) for task groups that don’t generate results and the advanced [custom actor executors](https://github.com/apple/swift-evolution/blob/main/proposals/0392-custom-actor-executors.md) feature for controlling the exact environment that an actor is run in.
+
+A full list of Swift 5.9 Evolution proposals can be found at the end of this post.
+
+## Developer Experience
+
+### Crash Handling
+
+On Linux, the Swift runtime will now catch program crashes and Swift runtime errors and display a backtrace on the program’s output. The backtracer is out-of-process and includes support for `async` functions.
+
+This feature is also available on macOS, but is disabled by default. To enable it, set `SWIFT_BACKTRACE=enable=yes` and sign your program with the `com.apple.security.get-task-allow` entitlement.
+
+### Debugging
+
+Swift 5.9 introduces new features to [LLDB](https://lldb.llvm.org/) and the Swift compiler aimed at making Swift debugging faster and more reliable.
+
+The `p` and `po` commands will now bypass the Swift compiler when evaluating simple expressions, which will make printing local and member variables as fast as using the `frame variable` or `v` command.
+
+Swift expressions can now refer to generic type parameters. This allows setting a conditional breakpoint in a generic function that only triggers when a type parameter is instantiated with a specific concrete type.
+
+Finally, the debug info produced by the Swift compiler is now more precise when it comes to scoping of local variables.
+
+For a more detailed discussion and examples of how to use these new features, stay tuned for a dedicated blog about debugging in Swift 5.9 coming soon!
+
+## Ecosystem
+
+### Swift Package Manager
+
+The following are some highlights from the changes introduced to the [Swift Package Manager](https://github.com/apple/swift-package-manager) in Swift 5.9:
+
+- Packages can make use of the new `package` access modifier, allowing access of symbols in another target / module within the same package without making them public. SwiftPM automatically sets the new compiler configuration to ensure this feature works out-of-the-box for packages.
+
+- The `CompilerPluginSupport` module enables defining macro targets. Macro targets allow authoring and distribution of custom Swift macros such as [expression macros](https://github.com/apple/swift-evolution/blob/main/proposals/0382-expression-macros.md).
+
+- The new `.embedInCode` resource rule allows embedding the contents of the resource into the executable by generating a byte array, e.g.
+
+  ```
+  struct PackageResources {
+    static let my_resource: [UInt8] = [104,101,108,108,111,32,119,111,114,108,100,10]
+  }
+  ```
+
+- The `allowNetworkConnections(scope:reason:)` setting gives a command plugin permissions to access the network. Permissions can be scoped to Unix domain sockets in general or specifically for Docker, as well as local or remote IP connections which can be limited by port. For non-interactive use cases, there is also a `--allow-network-connections` command-line flag to allow network connections for a particular scope.
+
+- SwiftPM can now publish to a registry following the publishing spec as defined in [SE-0391](https://github.com/apple/swift-evolution/blob/main/proposals/0391-package-registry-publish.md). SwiftPM also gains support for signed packages. Trust-on-first-use (TOFU) validation checks which previously only included fingerprints (e.g., checksums) has been extended to include signing identities, and it is enforced for source archives as well as package manifests.
+
+- A new `swift experimental-sdk` experimental command is now available for managing Swift SDK bundles that follow the format described in [SE-0387](https://github.com/apple/swift-evolution/blob/main/proposals/0387-cross-compilation-destinations.md).
+
+See the [Swift Package Manager changelog](https://github.com/apple/swift-package-manager/blob/main/CHANGELOG.md#swift-59) for the complete list of changes.
+
+### Swift Syntax
+
+[swift-syntax](https://github.com/apple/swift-syntax) has become an essential tool to create macros in Swift 5.9. In addition to the introduction of the modules that allow the creation of macros, swift-syntax has received major quality improvements:
+
+- The documentation of swift-syntax has been greatly expanded and can be viewed at [swiftpackageindex.com](https://swiftpackageindex.com/apple/swift-syntax).
+
+- The names of all syntax nodes and their children have been audited to be more consistent and accurately reflect the Swift language.
+
+- The error messages produced by the new SwiftParser have been greatly improved and it now produces better errors than the C++ parser in almost all cases.
+
+- As part of the Google Summer of Code project, incremental parsing has been introduced to swift-syntax, allowing e.g. an editor to only reparse those parts of a syntax tree that have changed.
+
+Over the last year, swift-syntax has been a huge success as an open source project. Since the release of Swift 5.8, more than 30 distinct open source contributors have contributed to the package accounting for more than 30% of the commits. In addition, community tools like [swift-ast-explorer.com](https://swift-ast-explorer.com) are an invaluable tool to explore and understand the SwiftSyntax tree. Thanks to everyone who contributed!
+
+### C++ Interoperability
+
+Swift 5.9 supports bidirectional interoperability with C++ and Objective-C++. You can now use a subset of C++ APIs in Swift and Swift APIs from C++. For information on enabling C++ interoperability and the supported language subset, please refer to the [documentation](/documentation/cxx-interop/).
+
+C++ interoperability is an actively evolving feature of Swift and developed by the focused [C++ Interoperability Workgroup](/cxx-interop-workgroup/). Certain aspects of the design and functionality might change in future releases of Swift, as the Swift community gathers feedback from real world adoption in mixed Swift and C++ codebases.
+
+Join the Swift community and the C++ Interoperability Workgroup to provide feedback and help shape the evolution of the feature.
+
+### Server
+
+The server workgroup has been busy driving the adoption of Swift concurrency in the server ecosystem, including making use of new 5.9 features such as [custom actor executors](https://github.com/apple/swift-evolution/blob/main/proposals/0392-custom-actor-executors.md). The group recently published their [annual update for 2023](/blog/sswg-update-2023/) which goes into details of this work.
+
+### Website
+
+Along with the 5.9 release, the website workgroup has revamped the content on key pages of [Swift.org](/), including a richer home page, new and detailed getting-started guides, and clearer download and install instructions.
+
+### Windows Platform
+
+The Windows installation received new functionality to inject the module maps via a VFS overlay dynamically rather than needing to modify the Visual Studio installation. This change breaks the dependency order for installation; it is now possible to install either Visual Studio or the Swift toolchain first. This also eliminates the need to repair the installation after an upgrade to Visual Studio. As part of the continued refinement to the installer, initial work towards versioning the toolchain installation lays the foundation for the ability to have multiple parallel toolchain versions installed side-by-side on Windows.
+
+Alongside this improved handling of Visual Studio, the Swift toolchain added new flags (`-windows-sdk-root`, `-windows-sdk-version`, `-visualc-tools-root`, `-visualc-tools-version`) to help control the Windows SDK and Visual C++ tools that it builds against. The Windows SDK (`WinSDK`) module also saw improvements in the coverage of the SDK, enabling access to a wider set of system APIs. The Visual C++ (`vcruntime`) module was greatly restructured to support C++ interoperability.
+
+Structured Concurrency is now significantly more stable on Windows. Backtraces are still a work in progress, as the Windows ABI currently prohibits the necessary optimizations required for the proper implementation of the feature.
+
+Improvements to path handling in the LSP and SPM makes both of these tools more robust on Windows. LLDB also saw initial work towards improving support for Windows, enabling fundamental debugging workflows in LLDB on Windows. While still a work in progress, this significantly improves the developer experience on Windows.
+
+Small improvements continue to be made to reduce the size of the toolchain. Although the impact of this is minimal, some of the tools are now smaller in size due to more careful curation of linking. This also reduces the number of artifacts that are contained in a toolchain installation.
+
+## Downloads
+
+<!-- TODO: Add section content -->
+
+## Swift Evolution Appendix
+
+The following language, standard library, and Swift Package Manager proposals were accepted through the [Swift Evolution](https://github.com/apple/swift-evolution) process and [implemented in Swift 5.9](https://apple.github.io/swift-evolution/#?version=5.9).
+
+- SE-0366: [`consume` operator to end the lifetime of a variable binding](https://github.com/apple/swift-evolution/blob/main/proposals/0366-move-function.md)
+- SE-0374: [Add sleep(for:) to Clock](https://github.com/apple/swift-evolution/blob/main/proposals/0374-clock-sleep-for.md)
+- SE-0377: [`borrowing` and `consuming` parameter ownership modifiers](https://github.com/apple/swift-evolution/blob/main/proposals/0377-parameter-ownership-modifiers.md)
+- SE-0380: [`if` and `switch` expressions](https://github.com/apple/swift-evolution/blob/main/proposals/0380-if-switch-expressions.md)
+- SE-0381: [DiscardingTaskGroups](https://github.com/apple/swift-evolution/blob/main/proposals/0381-task-group-discard-results.md)
+- SE-0382: [Expression Macros](https://github.com/apple/swift-evolution/blob/main/proposals/0382-expression-macros.md)
+- SE-0384: [Importing Forward Declared Objective-C Interfaces and Protocols](https://github.com/apple/swift-evolution/blob/main/proposals/0384-importing-forward-declared-objc-interfaces-and-protocols.md)
+- SE-0386: [New access modifier: `package`](https://github.com/apple/swift-evolution/blob/main/proposals/0386-package-access-modifier.md)
+- SE-0388: [Convenience Async[Throwing]Stream.makeStream methods](https://github.com/apple/swift-evolution/blob/main/proposals/0388-async-stream-factory.md)
+- SE-0389: [Attached Macros](https://github.com/apple/swift-evolution/blob/main/proposals/0389-attached-macros.md)
+- SE-0390: [Noncopyable structs and enums](https://github.com/apple/swift-evolution/blob/main/proposals/0390-noncopyable-structs-and-enums.md)
+- SE-0392: [Custom Actor Executors](https://github.com/apple/swift-evolution/blob/main/proposals/0392-custom-actor-executors.md)
+- SE-0393: [Value and Type Parameter Packs](https://github.com/apple/swift-evolution/blob/main/proposals/0393-parameter-packs.md)
+- SE-0394: [Package Manager Support for Custom Macros](https://github.com/apple/swift-evolution/blob/main/proposals/0394-swiftpm-expression-macros.md)
+- SE-0395: [Observation](https://github.com/apple/swift-evolution/blob/main/proposals/0395-observability.md)
+- SE-0396: [Conform `Never` to `Codable`](https://github.com/apple/swift-evolution/blob/main/proposals/0396-never-codable.md)
+- SE-0397: [Freestanding Declaration Macros](https://github.com/apple/swift-evolution/blob/main/proposals/0397-freestanding-declaration-macros.md)
+- SE-0398: [Allow Generic Types to Abstract Over Packs](https://github.com/apple/swift-evolution/blob/main/proposals/0398-variadic-types.md)
+- SE-0399: [Tuple of value pack expansion](https://github.com/apple/swift-evolution/blob/main/proposals/0399-tuple-of-value-pack-expansion.md)
+- SE-0400: [Init Accessors](https://github.com/apple/swift-evolution/blob/main/proposals/0400-init-accessors.md)
+- SE-0401: [Remove Actor Isolation Inference caused by Property Wrappers](https://github.com/apple/swift-evolution/blob/main/proposals/0401-remove-property-wrapper-isolation.md)
+- SE-0402: [Generalize `conformance` macros as `extension` macros](https://github.com/apple/swift-evolution/blob/main/proposals/0402-extension-macros.md)