Swift

https://github.com/swiftlang/swift-migration-guide
Admin
The Swift Concurrency Migration Guide provides documentation and resources for migrating Swift...
Tokens:32,308
Snippets:268
Trust Score:8.8
License:Apache-2.0
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Output of swift package migrate

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/FeatureMigration.md

Expected output when running swift package migrate: starts a build, applies migration fix-its, then updates the manifest.

```text
> Starting the build.
... regular build output with migration diagnostics ...
> Applying fix-its.
> Updating manifest.
```

--------------------------------

### Swift: Extension method on protocol P

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Example of an extension method on protocol P that can be affected by retroactive @MainActor annotations. Used to illustrate ABI implications.

```swift
extension P {
  public func onChange(action: @escaping @Sendable () -> Void)
}
```

--------------------------------

### Git diff of migration changes

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/FeatureMigration.md

Example git diff showing the changes applied by swift package migrate: adds swiftSettings to Package.swift and adds @concurrent to a function in TargetA.swift.

```diff
diff --git a/Package.swift b/Package.swift
index a1e587c..11097be 100644
--- a/Package.swift
+++ b/Package.swift
@@ -14,10 +14,16 @@ let package = Package(
    targets: [
        .target(
            name: "TargetA",
+            swiftSettings: [
+                .enableUpcomingFeature("NonisolatedNonsendingByDefault"),
+            ]
        ),
    ]

diff --git a/Sources/packtest/packtest.swift b/Sources/packtest/packtest.swift
index 85253f5..8498bb5 100644
--- a/Sources/TargetA/TargetA.swift
+++ b/Sources/TargetA/TargetA.swift
@@ -1,5 +1,5 @@
struct S: Sendable {
-  func alwaysSwitch() async {}
+  @concurrent func alwaysSwitch() async {}
}
```

--------------------------------

### Manual migration with shared SwiftSetting

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/FeatureMigration.md

Manual migration example: add .enableUpcomingFeature to a shared SwiftSetting array and reference it in the target's swiftSettings. Note the duplicate 'let targetSettings:' line appears in the source.

```swift
// swift-tools-version: 6.2

let targetSettings: [SwiftSetting] = [
    // ...
    .enableUpcomingFeature("NonisolatedNonsendingByDefault")
]

let targetSettings:
let package = Package(
    name: "MyPackage",
    products: [
        // ...
    ],
    targets: [
        .target(
            name: "TargetA",
            swiftSettings: targetSettings
        ),
    ]
)
```

--------------------------------

### Build and preview the documentation with DocC

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/README.md

Run the DocC preview command in the repository's root directory to build and preview the documentation locally. If DocC is installed via Xcode, use 'xcrun docc' instead of 'docc'.

```shell
docc preview Guide.docc
```

```shell
xcrun docc
```

--------------------------------

### Preconcurrency Import Example

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Uses @preconcurrency import to downgrade diagnostics for a non-Sendable type from another module. In Swift 6 mode, the error becomes a warning; in Swift 5 mode, no diagnostics are produced.

```swift
// ColorComponents defined here
@preconcurrency import UnmigratedModule

func updateStyle(backgroundColor: ColorComponents) async {
    // crossing an isolation domain here
    await applyBackground(backgroundColor)
}
```

--------------------------------

### Package.swift with swift-tools-version 6.0 and per-target language mode

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Use this Package.swift to enable Swift 6 language mode for all targets by default, with the ability to set a per-target language mode using the swiftLanguageMode build setting. The example shows a target that uses the default mode (6) and another that still requires Swift 5.

```swift
// swift-tools-version: 6.0

let package = Package(
    name: "MyPackage",
    products: [
        // ...
    ],
    targets: [
        // Uses the default tools language mode (6)
        .target(
            name: "FullyMigrated",
        ),
        // Still requires 5
        .target(
            name: "NotQuiteReadyYet",
            swiftSettings: [
                .swiftLanguageMode(.v5)
            ]
        )
    ]
)
```

--------------------------------

### Crossing isolation domains with await

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

A call that crosses an isolation boundary must be made asynchronously. This example shows a @MainActor function switching to an actor's domain using await.

```swift
@MainActor
func stockUp() {
    // beginning execution on MainActor
    let food = Pineapple()

    // switching to the island actor's domain
    await island.store(food)
}
```

--------------------------------

### Error: main actor-isolated default value in a nonisolated context

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

The compiler error produced by the previous example, indicating that the default value is main actor-isolated in a nonisolated context.

```text
 7 | 
 8 | struct Stylers {
 9 |     static let window = WindowStyler()
   |                `- error: main actor-isolated default value in a nonisolated context
10 | }
11 | 
```

--------------------------------

### Non-isolated type

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

An example of a non-isolated type. This simple class, with no superclass or protocol conformances, uses the default isolation.

```swift
class Chicken {
    let name: String
    var currentHunger: HungerLevel
}
```

--------------------------------

### Accidental MainActor Isolation in NSJetPack

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Example of a protocol method that is accidentally MainActor-isolated due to the type annotation, but has different threading semantics.

```objc
NS_SWIFT_UI_ACTOR // SDK author annotated using MainActor in recent SDK audit
@protocol NSJetPack // fictional protocol
/* Return YES if this jetpack supports flying at really high altitude!
 
 JetPackKit invokes this method at a variety of times, and not always on the main thread. For example, ...
*/
@property(readonly) BOOL supportsHighAltitude;

@end
```

--------------------------------

### Non-atomic deposit function with suspension points

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Actors do not ensure atomicity across suspension points. This example shows a deposit function that incorrectly assumes the actor's food value will not change between asynchronous calls.

```swift
func deposit(pineapples: [Pineapple], onto island: Island) async {
   var food = await island.food
   food += pineapples
   await island.store(food)
}
```

--------------------------------

### Latent Isolation Example

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Shows a non-isolated function that crosses to MainActor, causing a need for Sendable. This is the most common form of latent isolation.

```swift
@MainActor
func applyBackground(_ color: ColorComponents) {
}

func updateStyle(backgroundColor: ColorComponents) async {
    await applyBackground(backgroundColor)
}
```

--------------------------------

### Error: call to actor-isolated instance method 'stopNotifications()' in a synchronous nonisolated context

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

The compiler error produced by the previous example, showing that the call to stopNotifications() is not allowed in a synchronous nonisolated context.

```text
error: call to actor-isolated instance method 'stopNotifications()' in a synchronous nonisolated context
 5 |     deinit {
 6 |         // this is non-isolated
 7 |         store.stopNotifications()
   |               `- error: call to actor-isolated instance method 'stopNotifications()' in a synchronous nonisolated context
 8 |     }
 9 | }
```

--------------------------------

### Error for main actor-isolated method satisfying nonisolated protocol requirement

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

The compiler error produced by the previous example in Swift 6 mode. It suggests adding 'nonisolated' to the method.

```text
 5 | @MainActor
 6 | class WindowStyler: Styler {
 7 |     func applyStyle() {
   |          |- error: main actor-isolated instance method 'applyStyle()' cannot be used to satisfy nonisolated protocol requirement
   |          `- note: add 'nonisolated' to 'applyStyle()' to make this instance method not isolated to the actor
 8 |         // access main-actor-isolated state
 9 |     }
```

--------------------------------

### Closure inherits enclosing isolation

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Closures are isolated to the context they are formed in. This example shows a closure passed to LazySequence.map that inherits MainActor isolation.

```swift
@MainActor
class Model { ... }

@MainActor
class C {
    var models: [Model] = []

    func mapModels<Value>(
      _ keyPath: KeyPath<Model, Value>
    ) -> some Collection<Value> {
        models.lazy.map { $0[keyPath: keyPath] }
    }
}

```

--------------------------------

### Implicitly-Sendable Type Example

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Shows a public struct with Sendable properties that is not implicitly Sendable, causing an error when crossing isolation boundaries. The compiler only treats non-public types as implicitly Sendable.

```swift
public struct ColorComponents {
    public let red: Float
    public let green: Float
    public let blue: Float
}

@MainActor
func applyBackground(_ color: ColorComponents) {
}

func updateStyle(backgroundColor: ColorComponents) async {
    await applyBackground(backgroundColor)
}
```

--------------------------------

### Task inherits enclosing isolation

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

The Task initializer captures the isolation of the enclosing context by default, but explicit isolation can be specified. This example shows a MainActor-isolated task and a task isolated to MyGlobalActor.

```swift
@MainActor
func eat(food: Pineapple) {
    // the static isolation of this function's declaration is
    // captured by the closure created here
    Task {
        // allowing the closure's body to inherit MainActor-isolation
        Chicken.prizedHen.eat(food: food)
    }

    Task { @MyGlobalActor in
        // this task is isolated to `MyGlobalActor`
    }
}

```

--------------------------------

### Actor-isolated type with non-Sendable and Sendable properties

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Actors are implicitly Sendable because they protect all state in their own isolation domain. This example shows an actor with a non-Sendable property (flock) and a Sendable property (food).

```swift
actor Island {
    var flock: [Chicken]  // non-Sendable
    var food: [Pineapple] // Sendable
}
```

--------------------------------

### Global-actor-isolated type with non-Sendable and Sendable properties

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Global-actor-isolated types are also implicitly Sendable because their state is protected by an actor. This example shows a @MainActor class with non-Sendable and Sendable properties.

```swift
@MainActor
class ChickenValley {
    var flock: [Chicken]  // non-Sendable
    var food: [Pineapple] // Sendable
}
```

--------------------------------

### Enqueue all work items to a task group (potentially wasteful)

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/RuntimeBehavior.md

Shows the naive approach of adding all work items to a task group at once. This can create thousands of tasks concurrently, which may be inefficient because each task allocates memory for suspension and execution.

```swift
// Potentially wasteful -- perhaps this creates thousands of tasks concurrently (?!)

let lotsOfWork: [Work] = ...
await withTaskGroup(of: Something.self) { group in
  for work in lotsOfWork {
    // If this is thousands of items, we may end up creating a lot of tasks here.
    group.addTask {
      await work.work()
    }
  }

  for await result in group {
    process(result) // process the result somehow, depends on your needs
  }
}
```

--------------------------------

### Swift: Using @preconcurrency to preserve ABI

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows how to apply @preconcurrency to function declarations to downgrade requirement failures to warnings and preserve ABI.

```swift
@preconcurrency @MainActor
public func runOnMain() { ... }

@preconcurrency
public func performConcurrently(completion: @escaping @MainActor () -> Void) { ... }
```

--------------------------------

### Run swift with -strict-concurrency=complete

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Pass -strict-concurrency=complete to the swift or swiftc command to enable complete concurrency checking for a single file.

```bash
~ swift -strict-concurrency=complete main.swift
```

--------------------------------

### Migrate all targets with swift package migrate

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/FeatureMigration.md

Migrates all targets in the package to the specified upcoming feature. Requires a clean working tree and a working build; applies fix-its in place.

```sh
swift package migrate --to-feature NonisolatedNonsendingByDefault
```

--------------------------------

### Create a task to run concurrent code

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

A task is a unit of work that can run concurrently. Tasks run code in order and can be isolated to an actor or global actor, or be non-isolated.

```swift
Task {
    flock.map(Chicken.produce)
}
```

--------------------------------

### Making init nonisolated to allow non-isolated initialization

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Shows how to make an initializer nonisolated so it can be called from any isolation domain, while still ensuring isolated state is only accessible from the MainActor.

```swift
@MainActor
class WindowStyler {
    private var viewStyler = ViewStyler()
    private var primaryStyleName: String

    nonisolated init(name: String) {
        self.primaryStyleName = name
        // type is fully-initialized here
    }
}
```

--------------------------------

### Composition of Sendable techniques

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Combines manual synchronization and actor isolation in a single type to better describe internal semantics while retaining compiler's automated isolation checking.

```swift
final class Style: Sendable {
    private nonisolated(unsafe) var background: ColorComponents
    private let queue: DispatchQueue

    @MainActor
    private var foreground: ColorComponents
}
```

--------------------------------

### Explicit MainActor context with MainActor.run

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Shows manually switching to the MainActor using `MainActor.run` in an asynchronous context. Useful during migration when a type should be @MainActor but has not been updated yet, but the goal should ultimately be static isolation with @MainActor.

```swift
// type that should be MainActor, but has not been updated yet
class PersonalTransportation {
}

await MainActor.run {
    // isolated to the MainActor here
    let transport = PersonalTransportation()
    
    // ...
}
```

--------------------------------

### Enable StrictConcurrency with SwiftSetting.enableExperimentalFeature

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Use this Swift package manifest setting with Swift 5.9 or 5.10 tools to enable complete concurrency checking as warnings for a target in a pre-Swift 6 language mode.

```swift
.target(
  name: "MyTarget",
  swiftSettings: [
    .enableExperimentalFeature("StrictConcurrency")
  ]
)
```

--------------------------------

### Enable StrictConcurrency with SwiftSetting.enableUpcomingFeature

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Use this Swift package manifest setting with Swift 6.0 tools or later to enable complete concurrency checking as warnings for a target in a pre-Swift 6 language mode.

```swift
.target(
  name: "MyTarget",
  swiftSettings: [
    .enableUpcomingFeature("StrictConcurrency")
  ]
)
```

--------------------------------

### Package.swift with swiftLanguageVersions for backward compatibility

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Use this single Package.swift to enable Swift 6 language mode when available while still supporting older modes. It uses swift-tools-version 5.9 and specifies swiftLanguageVersions with .version("6") and .v5.

```swift
// swift-tools-version: 5.9

let package = Package(
    name: "MyPackage",
    products: [
        // ...
    ],
    targets: [
        .target(
            name: "FullyMigrated",
        ),
    ],
    // `swiftLanguageVersions` and `.version("6")` to support pre 6.0 swift-tools-version.
    swiftLanguageVersions: [.version("6"), .v5]
)
```

--------------------------------

### Command-line invocation with swift -swift-version 6

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Use this command to enable Swift 6 language mode when running swift or swiftc directly. Pass -swift-version 6 to the interpreter.

```bash
~ swift -swift-version 6 main.swift
```

--------------------------------

### Swift: Explicit nonisolated extension method

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Workaround for ABI compatibility by explicitly marking the extension method as nonisolated.

```swift
extension P {
  nonisolated public func onChange(action: @escaping @Sendable () -> Void)
}
```

--------------------------------

### Diff: Adding @MainActor to protocol and class declarations

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows the source and ABI incompatible change of adding @MainActor to a protocol and a class. The diff highlights the added annotations.

```diff
-public protocol P
+@MainActor public protocol P

-public class C
+@MainActor public class C
```

--------------------------------

### Use -Xswiftc -strict-concurrency=complete with swift build and swift test

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Pass -strict-concurrency=complete to Swift package manager commands using the -Xswiftc flag to gauge concurrency warnings before adding the flag permanently to the manifest.

```bash
~ swift build -Xswiftc -strict-concurrency=complete
~ swift test -Xswiftc -strict-concurrency=complete
```

--------------------------------

### Add sending to parameter (source and ABI incompatible)

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows source and ABI incompatible change: adding 'sending' to a parameter is more restrictive at the caller.

```diff
-public func takeValue(_: NotSendable)
+public func takeValue(_: sending NotSendable)
```

--------------------------------

### Migrate a single target with --targets

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/FeatureMigration.md

Migrates only the specified target (TargetA) to the upcoming feature. Use this to migrate targets one at a time.

```sh
swift package migrate --targets TargetA --to-feature NonisolatedNonsendingByDefault
```

--------------------------------

### NSObjCRuntime Swift Concurrency Macros

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Annotation macros available in NSObjCRuntime.h for Swift concurrency.

```objc
  NS_SWIFT_SENDABLE
  NS_SWIFT_NONSENDABLE
  NS_SWIFT_NONISOLATED
  NS_SWIFT_UI_ACTOR
  NS_SWIFT_SENDING

  NS_SWIFT_DISABLE_ASYNC
  NS_SWIFT_ASYNC(COMPLETION_BLOCK_INDEX)
  NS_REFINED_FOR_SWIFT_ASYNC(COMPLETION_BLOCK_INDEX)
  NS_SWIFT_ASYNC_NAME
  NS_SWIFT_ASYNC_NOTHROW
  NS_SWIFT_UNAVAILABLE_FROM_ASYNC(msg)
```

--------------------------------

### Version-specific manifest Package@swift-5.9.swift for pre-6 toolchains

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Use this manifest to support Swift 5.9 toolchains when you need per-target swiftLanguageMode. It uses swift-tools-version 5.9 and does not include the swiftLanguageMode setting.

```swift
// swift-tools-version: 5.9

let package = Package(
    name: "MyPackage",
    products: [
        // ...
    ],
    targets: [
        .target(
            name: "FullyMigrated",
        ),
        .target(
            name: "NotQuiteReadyYet",
        )
    ]
)
```

--------------------------------

### Adapt callback-based API to async with withCheckedContinuation

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Wrap a callback-based function (updateStyle(backgroundColor:completionHandler:)) into an asynchronous version using withCheckedContinuation. The continuation must be resumed exactly once; missing it leaves the task suspended, and resuming more than once crashes with a checked continuation. The async version resumes execution in the original context, and the final call demonstrates its use.

```swift
func updateStyle(backgroundColor: ColorComponents, completionHandler: @escaping () -> Void) {
    // ...
}
```

```swift
func updateStyle(backgroundColor: ColorComponents) async {
    await withCheckedContinuation { continuation in
        updateStyle(backgroundColor: backgroundColor) {
            // ... do some work here ...

            continuation.resume()
        }
    }
}
```

```swift
await updateStyle(backgroundColor: color)
// style has been updated
```

--------------------------------

### Command-line invocations with -Xswiftc -swift-version 6

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Use these commands to pass -swift-version 6 to the Swift compiler when building or testing a Swift package. The -Xswiftc flag forwards the option to the compiler.

```bash
~ swift build -Xswiftc -swift-version -Xswiftc 6
~ swift test -Xswiftc -swift-version -Xswiftc 6
```

--------------------------------

### Using @preconcurrency on library APIs

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Apply @preconcurrency to stage in new concurrency requirements without breaking source or ABI compatibility. Errors from these APIs are suppressed with minimal concurrency checking, and downgraded to warnings with complete checking or Swift 6 mode. For ABI, @preconcurrency mangles symbol names without concurrency annotations; additional annotations require @_silgen_name for precise control.

```swift
@preconcurrency @MainActor
struct S { ... }

@preconcurrency
public func performConcurrently(
  completion: @escaping @Sendable () -> Void
) { ... }
```

--------------------------------

### Clang Swift Concurrency Annotations

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Clang attributes for Swift concurrency in C/Objective-C code

```c
  __attribute__((swift_attr("@Sendable")))
  __attribute__((swift_attr("@_nonSendable")))
  __attribute__((swift_attr("nonisolated")))
  __attribute__((swift_attr("@UIActor")))
  __attribute__((swift_attr("sending")))

  __attribute__((swift_async(none)))
  __attribute__((swift_async(not_swift_private, COMPLETION_BLOCK_INDEX))
  __attribute__((swift_async(swift_private, COMPLETION_BLOCK_INDEX)))
  __attribute__((__swift_async_name__(NAME)))
  __attribute__((swift_async_error(none)))
  __attribute__((__swift_attr__("@_unavailableFromAsync(message: \"" msg "\")")))

```

--------------------------------

### Add sending to result (source and ABI compatible)

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows source and ABI compatible change: adding 'sending' to a result lifts restrictions in client code.

```diff
-public func getValue() -> NotSendable
+public func getValue() -> sending NotSendable
```

--------------------------------

### Calling MainActor-isolated initializer from non-isolated context

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Shows a non-isolated type attempting to call a MainActor-isolated initializer, which results in an error about a main actor-isolated default value in a nonisolated context.

```swift
@MainActor
class WindowStyler {
    init() {
    }
}

struct Stylers {
    static let window = WindowStyler()
}
```

--------------------------------

### Manifest update failure error

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/FeatureMigration.md

Error message when swift package migrate cannot update the manifest, e.g., when settings are factored out into a variable. Manual migration is required.

```text
error: Could not update manifest for 'TargetA' (unable to find array literal for 'swiftSettings' argument). Please enable 'NonisolatedNonsendingByDefault' features manually.
```

--------------------------------

### Non-Sendable global reference type

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

A global static let of a non-Sendable class type, which is unsafe to share across isolation domains.

```swift
class WindowStyler {
    var background: ColorComponents

    static let defaultStyler = WindowStyler()
}
```

--------------------------------

### Replace @Sendable with sending on closure parameter

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows replacing @Sendable with sending on a closure parameter, a source compatible but ABI incompatible change.

```diff
-public func takeValue(_: @Sendable @escaping () -> Void)
+public func takeValue(_: sending @escaping () -> Void)
```

--------------------------------

### Diff: Adding @MainActor to function declarations and types

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows the source and ABI incompatible change of adding @MainActor to a function declaration and a function type.

```diff
-public func runOnMain()
+@MainActor public func runOnMain()

-public func performConcurrently(completion: @escaping () -> Void)
+public func performConcurrently(completion: @escaping @MainActor () -> Void)
```

--------------------------------

### Xcode xcconfig setting SWIFT_VERSION = 6

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Set the SWIFT_VERSION build setting to 6 in an xcconfig file to enable Swift 6 language mode for an Xcode project or target.

```plaintext
// In a Settings.xcconfig

SWIFT_VERSION = 6;
```

--------------------------------

### NS_SWIFT_UI_ACTOR Protocol Annotation

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Marking a protocol with NS_SWIFT_UI_ACTOR to isolate its methods to the main actor.

```objc
NS_SWIFT_UI_ACTOR
@protocol NSJetPack // fictional protocol
  // ...
@end
```

--------------------------------

### Using @preconcurrency with @MainActor protocol

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Staging in diagnostics caused by adding global actor isolation on a protocol using @preconcurrency. This preserves source compatibility with clients that have not yet adopted concurrency.

```swift
@preconcurrency @MainActor
protocol Styler {
    func applyStyle()
}
```

--------------------------------

### Usage-only isolation with @MainActor and MainActor.assumeIsolated

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Demo of usage-only isolation: the type is @MainActor-isolated, but a client class uses it only inside MainActor.assumeIsolated to gradually adapt. This helps contain changes but still leaves the isolation requirements invisible to clients.

```swift
@MainActor
class WindowStyler {
    // ...
}

class UIStyler {
    @MainActor
    private let windowStyler: WindowStyler
    
    func applyStyle() {
        MainActor.assumeIsolated {
            windowStyler.applyStyle()
        }
    }
}

```

--------------------------------

### Mark public class as @preconcurrency @MainActor

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Use @preconcurrency to mark the isolation as conditional on the client module having complete checking enabled. This preserves source compatibility with clients that have not yet adopted Swift 6.

```Swift
@preconcurrency @MainActor
public class WindowStyler {
    // ...
}

```

--------------------------------

### Add Sendable generic requirement (incompatible)

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows the source and ABI incompatible change of adding a Sendable conformance requirement to a generic type or function. This places a restriction on generic arguments passed by the client.

```diff
-public func generic<T>
+public func generic<T> where T: Sendable
```

--------------------------------

### Internalize isolation with @MainActor and MainActor.assumeIsolated

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Shows two alternative designs for a Swift type: one with full @MainActor static isolation, and one with only the stored property isolated and internal dynamic isolation via MainActor.assumeIsolated. Use the second approach only as a temporary measure when you want to localize changes and avoid impacting clients, though it hides the type's true isolation requirements.

```swift
@MainActor
class WindowStyler {
    private var backgroundColor: ColorComponents

    func applyStyle() {
        // ...
    }
}

```

```swift
class WindowStyler {
    @MainActor
    private var backgroundColor: ColorComponents

    func applyStyle() {
        MainActor.assumeIsolated {
            // use and interact with other `MainActor` state
        }
    }
}

```

--------------------------------

### Final class conforming to Sendable with immutable Sendable properties

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

To make a class Sendable, it must contain no mutable state and all immutable properties must be Sendable. The compiler can only validate the implementation of final classes.

```swift
final class Chicken: Sendable {
    let name: String
}
```

--------------------------------

### Making protocol requirement asynchronous

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Changing a synchronous requirement to async offers more flexibility for conforming types, allowing isolated implementations.

```swift
protocol Styler {
    func applyStyle() async
}
```

--------------------------------

### Use an intermediate type to satisfy protocol inheritance

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

When a protocol requires inheritance and the conforming type cannot inherit (e.g., actors), introduce an intermediate class that inherits the required superclass and conforms to the protocol. This requires structural changes to the conforming type.

```swift
class UIStyler {
}

protocol Styler: UIStyler {
    func applyStyle()
}

// actors cannot have class-based inheritance
actor WindowStyler: Styler {
}
```

```swift
// class with necessary superclass
class CustomWindowStyle: UIStyler {
}

// now, the conformance is possible
extension CustomWindowStyle: Styler {
    func applyStyle() {
    }
}
```

--------------------------------

### Adopt sending in initializer parameter

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

For initializers, 'sending' preserves the default ownership convention, so no explicit ownership modifier is needed when adopting 'sending' on initializer parameters.

```swift
public class C {
  public init(ns: sending NotSendable)
}
```

--------------------------------

### Set SWIFT_STRICT_CONCURRENCY in xcconfig

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/EnableDataRaceSafety.md

Set SWIFT_STRICT_CONCURRENCY to complete in an xcconfig file to enable complete concurrency checking in an Xcode project.

```plaintext
// In a Settings.xcconfig

SWIFT_STRICT_CONCURRENCY = complete;
```

--------------------------------

### Using unstructured Task in deinit to access isolated values

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Shows how to use an unstructured Task in a deinitializer to capture and operate on isolated values asynchronously, avoiding the need for synchronous access. Warns against capturing self.

```swift
actor BackgroundStyler {
    // another actor-isolated type
    private let store = StyleStore()

    deinit {
        // no actor isolation here, so none will be inherited by the task
        Task { [store] in
            await store.stopNotifications()
        }
    }
}
```

--------------------------------

### Opt out of global actor isolation with nonisolated

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Use nonisolated to opt out of global actor isolation. Doing so disallows access to any protected state.

```swift
@MainActor
class ChickenValley {
    var flock: [Chicken]
    var food: [Pineapple]

    nonisolated func canGrow() -> PlantSpecies {
        // neither flock, food, nor any other MainActor-isolated
        // state is accessible here
    }
}
```

--------------------------------

### Add @Sendable to function type (incompatible)

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows the source and ABI incompatible change of adding @Sendable to a function type parameter.

```diff
-public func performConcurrently(completion: @escaping () -> Void)
+public func performConcurrently(completion: @escaping @Sendable () -> Void)
```

--------------------------------

### Adding @MainActor isolation to protocol

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Two ways to isolate a protocol requirement to the main actor: marking the entire protocol or marking the specific requirement.

```swift
// entire protocol
@MainActor
protocol Styler {
    func applyStyle()
}

// per-requirement
protocol Styler {
    @MainActor
    func applyStyle()
}
```

--------------------------------

### Accessing non-Sendable global from different isolation domains

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Two functions that could access the internal state of the non-Sendable global concurrently, requiring Sendable conformance or isolation.

```swift
func resetDefaultStyle() {
    WindowStyler.defaultStyler.background = ColorComponents(red: 1.0, green: 1.0, blue: 1.0)
}

@MainActor
class StyleStore {
    var stylers: [WindowStyler]

    func hasDefaultBackground() -> Bool {
        stylers.contains { $0.background == WindowStyler.defaultStyler.background }
    }
}
```

--------------------------------

### Crash trace: EXC_BREAKPOINT at dispatch_assert_queue_fail

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Runtime assertion failure trace from a Swift 6 app using an Objective-C library that lacks isolation annotations. The thread stops at the executor check injected by the concurrency runtime, revealing the mismatch between the actual queue and the expected MainActor executor.

```text
* thread #5, queue = 'com.apple.root.default-qos', stop reason = EXC_BREAKPOINT (code=1, subcode=0x1004f8a5c)
  * frame #0: 0x00000001004..... libdispatch.dylib`_dispatch_assert_queue_fail + 120
    frame #1: 0x00000001004..... libdispatch.dylib`dispatch_assert_queue + 196
    frame #2: 0x0000000275b..... libswift_Concurrency.dylib`swift_task_isCurrentExecutorImpl(swift::SerialExecutorRef) + 280
    frame #3: 0x0000000275b..... libswift_Concurrency.dylib`Swift._checkExpectedExecutor(_filenameStart: Builtin.RawPointer, _filenameLength: Builtin.Word, _filenameIsASCII: Builtin.Int1, _line: Builtin.Word, _executor: Builtin.Executor) -> () + 60
    frame #4: 0x00000001089..... MyApp.debug.dylib`@objc static JetPack.supportsHighAltitude.getter at <compiler-generated>:0
    ...
    frame #10: 0x00000001005..... libdispatch.dylib`_dispatch_root_queue_drain + 404
    frame #11: 0x00000001005..... libdispatch.dylib`_dispatch_worker_thread2 + 188
    frame #12: 0x00000001005..... libsystem_pthread.dylib`_pthread_wqthread + 228

```

--------------------------------

### Add Sendable conformance to a concrete type

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Shows the source and ABI compatible change of adding a Sendable conformance to a concrete type. Adding a conformance to Sendable can change overload resolution if the type satisfies more specialized requirements, but it is unlikely to break source compatibility or program behavior. Adding a Sendable conformance to a concrete type (not its type parameters) is always ABI compatible.

```diff
-public struct S
+public struct S: Sendable
```

--------------------------------

### Protocol conformance and isolation inference

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

A protocol conformance can implicitly affect isolation. Conformance on the type applies to the entire type, while conformance in an extension applies only within that extension.

```swift
@MainActor
protocol Feedable {
    func eat(food: Pineapple)
}

// inferred isolation applies to the entire type
class Chicken: Feedable {
}

// inferred isolation only applies within the extension
extension Pirate: Feedable {
}

```

--------------------------------

### Use 'sending' argument to pass non-Sendable value

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Use a 'sending' parameter to allow non-Sendable values to cross an isolation boundary when the compiler can prove safety. This imposes restrictions at call sites but can be easier than adding Sendable conformance, and works for types you do not control.

```swift
func updateStyle(backgroundColor: sending ColorComponents) async {
    // this boundary crossing can now be proven safe in all cases
    await applyBackground(backgroundColor)
}
```

--------------------------------

### Define actor with custom DispatchSerialQueue executor

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/IncrementalAdoption.md

Use this actor to migrate a type toward the actor model while maintaining compatibility with code that depends on DispatchQueue. The custom unowned executor ensures all actor methods run on the specified queue.

```Swift
actor LandingSite {
    private let queue = DispatchSerialQueue(label: "something")

    nonisolated var unownedExecutor: UnownedSerialExecutor {
        queue.asUnownedSerialExecutor()
    }

    func acceptTransport(_ transport: PersonalTransportation) {
        // this function will be running on queue
    }
}

```

--------------------------------

### Accessing global variable from different isolation domains

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Two functions with different isolation domains accessing the global variable, risking a data race.

```swift
@MainActor
func printSupportedStyles() {
    print("Supported styles: ", supportedStyleCount)
}

func addNewStyle() {
    let style = Style()

    supportedStyleCount += 1

    storeStyle(style)
}
```

--------------------------------

### Define a global variable

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

A simple global variable declaration that is non-isolated and mutable, leading to a concurrency error in Swift 6 mode.

```swift
var supportedStyleCount = 42
```

--------------------------------

### Preserve ownership convention with __shared sending

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Uses '__shared sending' to preserve ownership convention when adopting 'sending' in parameter position for functions other than initializers. Adding 'sending' changes name mangling, so any adoption must preserve it with @_silgen_name.

```swift
public func takeValue(_: __shared sending NotSendable)
```

--------------------------------

### Annotate a class with a global actor

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Global actors statically assign declarations to their isolation domain using an annotation. This class is isolated to MainActor, ensuring all access to its mutable state is from that domain.

```swift
@MainActor
class ChickenValley {
    var flock: [Chicken]
    var food: [Pineapple]
}
```

--------------------------------

### Global Isolation: @MainActor struct

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Adding global isolation to a type makes it implicitly Sendable. Accesses from other isolation domains must be asynchronous.

```swift
@MainActor
public struct ColorComponents {
    // ...
}
```

--------------------------------

### Unsafe access after crossing causes error

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Adding an access to 'chicken' after it has crossed into the island domain introduces a potential data race, so the compiler produces an error. This demonstrates the flow-sensitive nature of region-based isolation.

```swift
func populate(island: Island) async {
    let chicken = Chicken()

    await island.adopt(chicken)

    // this would result in an error
    chicken.eat(food: Pineapple())
}
```

--------------------------------

### Resolve Sendable generic requirement with @preconcurrency

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Resolves the source and ABI incompatibility of adding a Sendable generic requirement by applying @preconcurrency to the type or function declaration. This downgrades requirement failures to warnings and preserves ABI.

```swift
@preconcurrency
public func generic<T> where T: Sendable { ... }
```

--------------------------------

### Use computed property for constant global value

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

A computed property that consistently returns the same constant value is semantically equivalent to a `let` constant.

```swift
var supportedStyleCount: Int {
    42
}
```

--------------------------------

### Implicitly Sendable value types: Ripeness and Pineapple

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Both types are implicitly Sendable because they are composed entirely of Sendable value types. This conformance is not visible outside their defining module and must be declared explicitly for public API.

```swift
enum Ripeness {
    case hard
    case perfect
    case mushy(daysPast: Int)
}

struct Pineapple {
    var weight: Double
    var ripeness: Ripeness
}
```

--------------------------------

### Annotate conformance with @preconcurrency to suppress isolation errors

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Use @preconcurrency on a protocol conformance to suppress errors about isolation mismatches. This inserts runtime checks to ensure the static isolation of the conforming class is always enforced.

```swift
@MainActor
class WindowStyler: @preconcurrency Styler {
    func applyStyle() {
        // implementation body
    }
}
```

--------------------------------

### Disable isolation checking with nonisolated(unsafe)

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Using `nonisolated(unsafe)` to disable isolation checking when external synchronization protects the variable.

```swift
/// This value is only ever accessed while holding `styleLock`.
nonisolated(unsafe) var supportedStyleCount = 42
```

--------------------------------

### Safe crossing of non-Sendable value using region-based isolation

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

The compiler permits the non-Sendable 'chicken' to cross into the 'island' isolation domain because it can prove no data races occur. This exception is contingent on the surrounding code.

```swift
func populate(island: Island) async {
    let chicken = Chicken()

    await island.adopt(chicken)
}
```

--------------------------------

### Make global variable immutable with let

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Changing `var` to `let` makes the shared state immutable, allowing safe read-only access.

```swift
let supportedStyleCount = 42
```

--------------------------------

### Throttle concurrency with a task group (maxConcurrentWorkTasks)

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/RuntimeBehavior.md

Manually limits the number of concurrently added tasks to a task group. It submits a maximum of 10 tasks initially and adds more as results arrive, preventing excessive memory allocation from creating thousands of tasks at once.

```swift
let lotsOfWork: [Work] = ... 
let maxConcurrentWorkTasks = min(lotsOfWork.count, 10)
assert(maxConcurrentWorkTasks > 0)

await withTaskGroup(of: Something.self) { group in
    var submittedWork = 0
    for _ in 0..<maxConcurrentWorkTasks {
        group.addTask { // or 'addTaskUnlessCancelled'
            await lotsOfWork[submittedWork].work() 
        }
        submittedWork += 1
    }
    
    for await result in group {
        process(result) // process the result somehow, depends on your needs
    
        // Every time we get a result back, check if there's more work we should submit and do so
        if submittedWork < lotsOfWork.count, 
           let remainingWorkItem = lotsOfWork[submittedWork] {
            group.addTask { // or 'addTaskUnlessCancelled'
                await remainingWorkItem.work() 
            }  
            submittedWork += 1
        }
    }
}
```

--------------------------------

### Actor with implicit Sendable conformance

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Actors have an implicit Sendable conformance because their properties are protected by actor isolation. They receive their own isolation domain, allowing them to work with non-Sendable types internally.

```swift
actor Style {
    private var background: ColorComponents
}
```

--------------------------------

### Actor-isolated property access in deinit causes error

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Shows an actor with a deinitializer that tries to call an actor-isolated method, producing an error about calling actor-isolated instance method in a synchronous nonisolated context.

```swift
actor BackgroundStyler {
    // another actor-isolated type
    private let store = StyleStore()

    deinit {
        // this is non-isolated
        store.stopNotifications()
    }
}
```

--------------------------------

### Define an actor with isolated state

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

An actor defines an isolation domain that protects its stored properties. Methods are isolated to the actor instance, allowing synchronous access to its properties.

```swift
actor Island {
    var flock: [Chicken]
    var food: [Pineapple]

    func addToFlock() {
        flock.append(Chicken())
    }
}
```

--------------------------------

### Error Output for Non-Sendable Crossing

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Compiler error produced when a non-Sendable value crosses isolation boundaries. The error indicates sending 'backgroundColor' risks causing data races.

```text
 6 | 
 7 | func updateStyle(backgroundColor: ColorComponents) async {
 8 |     await applyBackground(backgroundColor)
   |           |- error: sending 'backgroundColor' risks causing data races
   |           `- note: sending task-isolated 'backgroundColor' to main actor-isolated global function 'applyBackground' risks causing data races between main actor-isolated and task-isolated uses
 9 | }
10 | 
```

--------------------------------

### Mark a method as nonisolated to avoid isolation mismatch

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

When the conforming type's isolation is the issue, mark the method as nonisolated. This makes isolated state and functions unavailable in the implementation, but can be appropriate for instance-independent configuration.

```swift
@MainActor
class WindowStyler: Styler {
    nonisolated func applyStyle() {
        // perhaps this implementation doesn't involve
        // other MainActor-isolated state
    }
}
```

--------------------------------

### Resolve @Sendable function type with @preconcurrency

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/LibraryEvolution.md

Resolves the source and ABI incompatibility of adding @Sendable to a function type by applying @preconcurrency to the enclosing function declaration. This downgrades requirement failures to warnings and preserves ABI.

```swift
@preconcurrency
public func performConcurrently(completion: @escaping @Sendable () -> Void)
```

--------------------------------

### Retroactive @unchecked Sendable conformance

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

Adds an @unchecked Sendable conformance to a type from a dependency. Use with extreme caution, especially for public API types.

```swift
extension ColorComponents: @retroactive @unchecked Sendable {
}
```

--------------------------------

### Actor with method using non-Sendable data

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

An actor can contain methods that use non-Sendable data internally, avoiding isolation boundaries. This provides a Sendable interface to those operations.

```swift
actor Style {
    private var background: ColorComponents

    func applyBackground(_ color: ColorComponents) {
        // make use of non-Sendable data here
    }
}
```

--------------------------------

### Opt out of actor isolation with nonisolated

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

Use the nonisolated keyword to disable actor isolation for a method. Non-isolated methods cannot synchronously access any protected state.

```swift
actor Island {
    var flock: [Chicken]
    var food: [Pineapple]

    nonisolated func canGrow() -> PlantSpecies {
        // neither flock nor food are accessible here
    }
}
```

--------------------------------

### Checked Sendable conformance for reference types

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

A final class can have a checked Sendable conformance if it meets specific conditions: must be final, cannot inherit from another class other than NSObject, and cannot have non-isolated mutable properties.

```swift
public struct ColorComponents: Sendable {
    // ...
}

final class Style: Sendable {
    private let background: ColorComponents
}
```

--------------------------------

### Isolated protocol requirement

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

A protocol requirement can be individually isolated, allowing fine-grained control over isolation inference for conforming types.

```swift
protocol Feedable {
    @MainActor
    func eat(food: Pineapple)
}

```

--------------------------------

### Satisfying nonisolated async requirement with isolated method

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

A @MainActor class can satisfy a nonisolated async protocol requirement with a synchronous isolated method. This is safe because generic code must call it asynchronously.

```swift
@MainActor
class WindowStyler: Styler {
    // matches, even though it is synchronous and actor-isolated
    func applyStyle() {
    }
}
```

--------------------------------

### Explicitly allowing parameter crossing with 'sending'

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/DataRaceSafety.md

The 'sending' keyword on the 'chicken' parameter guarantees at all call sites that the parameter will never be subject to unsafe access. Without it, the function would require 'Chicken' to conform to 'Sendable'.

```swift
func populate(island: Island, with chicken: sending Chicken) async {
    await island.adopt(chicken)
}
```

--------------------------------

### Under-specified protocol with nonisolated requirement

Source: https://github.com/swiftlang/swift-migration-guide/blob/main/Guide.docc/CommonProblems.md

A protocol without explicit isolation is nonisolated. A conforming type that is @MainActor cannot satisfy a synchronous nonisolated requirement because it would access actor-isolated state.

```swift
protocol Styler {
    func applyStyle()
}

@MainActor
class WindowStyler: Styler {
    func applyStyle() {
        // access main-actor-isolated state
    }
}
```
Tokens:
Raw