Add a defaultIsolation static method on SwiftSetting. (#8301)

Add a `defaultIsolation` static method on `SwiftSetting` to allow
specifying default actor isolation within a module.

### Motivation:

This is part of
https://forums.swift.org/t/pitch-control-default-actor-isolation-inference/77482.
Please leave feedback on the API shape in the pitch thread.

### Modifications:

I added a `defaultIsolation` case to `TargetBuildSettingDescription` and
a corresponding static method to `SwiftSetting`.

### Result:

Programmers will be allowed to set `defaultIsolation` per target in a
package manifest, e.g.:

```swift
swiftSettings: [
  .enableExperimentalFeature("StrictConcurrency"),
  .defaultIsolation(MainActor.self),
]
```

---------

Co-authored-by: Pavel Yaskevich <[email protected]>

Author: hborla

Sources/PackageDescription/BuildSettings.swift

@@ -462,6 +462,30 @@ public struct SwiftSetting: Sendable {
         return SwiftSetting(
             name: "swiftLanguageMode", value: [.init(describing: mode)], condition: condition)
     }
+
+    /// Set the default isolation to the given global actor type.
+    ///
+    /// - Since: First available in PackageDescription 6.2.
+    ///
+    /// - Parameters:
+    ///   - isolation: The type of global actor to use for default actor isolation
+    ///     inference. The only valid arguments are `MainActor.self` and `nil`.
+    ///   - condition: A condition that restricts the application of the build
+    ///     setting.
+    @available(_PackageDescription, introduced: 6.2)
+    public static func defaultIsolation(
+        _ isolation: MainActor.Type?,
+        _ condition: BuildSettingCondition? = nil
+    ) -> SwiftSetting {
+        let isolationString =
+            if isolation == nil {
+                "nonisolated"
+            } else {
+                "MainActor"
+            }
+        return SwiftSetting(
+            name: "defaultIsolation", value: [isolationString], condition: condition)
+    }
 }
 
 /// A linker build setting.

Sources/PackageLoading/ManifestJSONParser.swift

@@ -749,6 +749,15 @@ extension TargetBuildSettingDescription.Kind {
             }
 
             return .swiftLanguageMode(version)
+        case "defaultIsolation":
+            guard let rawValue = values.first else {
+                throw InternalError("invalid (empty) build settings value")
+            }
+            guard let isolation = TargetBuildSettingDescription.DefaultIsolation(rawValue: rawValue) else {
+                throw InternalError("unknown default isolation: \(rawValue)")
+            }
+
+            return .defaultIsolation(isolation)
         default:
             throw InternalError("invalid build setting \(name)")
         }

Sources/PackageLoading/PackageBuilder.swift

@@ -1252,6 +1252,17 @@ public final class PackageBuilder {
                 }
 
                 values = [version.rawValue]
+
+            case .defaultIsolation(let isolation):
+                switch setting.tool {
+                case .c, .cxx, .linker:
+                    throw InternalError("only Swift supports default isolation")
+
+                case .swift:
+                    decl = .OTHER_SWIFT_FLAGS
+                }
+
+                values = ["-default-isolation", isolation.rawValue]
             }
 
             // Create an assignment for this setting.

Sources/PackageModel/Manifest/TargetBuildSettingDescription.swift

@@ -25,6 +25,11 @@ public enum TargetBuildSettingDescription {
         case Cxx
     }
 
+    public enum DefaultIsolation: String, Codable, Hashable, Sendable {
+        case MainActor
+        case nonisolated
+    }
+
     /// The kind of the build setting, with associate configuration
     public enum Kind: Codable, Hashable, Sendable {
         case headerSearchPath(String)
@@ -42,13 +47,16 @@ public enum TargetBuildSettingDescription {
 
         case swiftLanguageMode(SwiftLanguageVersion)
 
+        case defaultIsolation(DefaultIsolation)
+
         public var isUnsafeFlags: Bool {
             switch self {
             case .unsafeFlags(let flags):
                 // If `.unsafeFlags` is used, but doesn't specify any flags, we treat it the same way as not specifying it.
                 return !flags.isEmpty
             case .headerSearchPath, .define, .linkedLibrary, .linkedFramework, .interoperabilityMode,
-                .enableUpcomingFeature, .enableExperimentalFeature, .strictMemorySafety, .swiftLanguageMode:
+                 .enableUpcomingFeature, .enableExperimentalFeature, .strictMemorySafety, .swiftLanguageMode,
+                 .defaultIsolation:
                 return false
             }
         }

Sources/PackageModel/ManifestSourceGeneration.swift

@@ -573,6 +573,17 @@ fileprivate extension SourceCodeFragment {
                 params.append(SourceCodeFragment(from: condition))
             }
             self.init(enum: setting.kind.name, subnodes: params)
+        case .defaultIsolation(let isolation):
+            switch isolation {
+            case .MainActor:
+                params.append(SourceCodeFragment("MainActor.self"))
+            case .nonisolated:
+                params.append(SourceCodeFragment("nil"))
+            }
+            if let condition = setting.condition {
+                params.append(SourceCodeFragment(from: condition))
+            }
+            self.init(enum: setting.kind.name, subnodes: params)
         }
     }
 
@@ -1010,6 +1021,8 @@ extension TargetBuildSettingDescription.Kind {
             return "strictMemorySafety"
         case .swiftLanguageMode:
             return "swiftLanguageMode"
+        case .defaultIsolation:
+            return "defaultIsolation"
         }
     }
 }

Tests/BuildTests/BuildPlanTests.swift

@@ -4308,6 +4308,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
                             condition: .init(platformNames: ["macos"], config: "debug")
                         ),
                         .init(tool: .swift, kind: .strictMemorySafety),
+                        .init(tool: .swift, kind: .defaultIsolation(.MainActor)),
                     ]
                 ),
                 TargetDescription(
@@ -4341,6 +4342,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
                             condition: .init(platformNames: ["macos"])
                         ),
                         .init(tool: .linker, kind: .unsafeFlags(["-Ilfoo", "-L", "lbar"])),
+                        .init(tool: .swift, kind: .defaultIsolation(.nonisolated)),
                     ]
                 ),
                 TargetDescription(
@@ -4433,6 +4435,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
                     "-Xcc", "-std=c++17",
                     "-enable-upcoming-feature", "BestFeature",
                     "-strict-memory-safety",
+                    "-default-isolation", "MainActor",
                     "-g",
                     "-Xcc", "-g",
                     "-Xcc", "-fno-omit-frame-pointer",
@@ -4441,7 +4444,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
             )
 
             let exe = try result.moduleBuildDescription(for: "exe").swift().compileArguments()
-            XCTAssertMatch(exe, [.anySequence, "-swift-version", "5", "-DFOO", "-g", "-Xcc", "-g", "-Xcc", "-fno-omit-frame-pointer", .end])
+            XCTAssertMatch(exe, [.anySequence, "-swift-version", "5", "-DFOO", "-default-isolation", "nonisolated", "-g", "-Xcc", "-g", "-Xcc", "-fno-omit-frame-pointer", .end])
 
             let linkExe = try result.buildProduct(for: "exe").linkArguments()
             XCTAssertMatch(linkExe, [.anySequence, "-lsqlite3", "-llibz", "-Ilfoo", "-L", "lbar", "-g", .end])
@@ -4498,6 +4501,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
                     "-enable-upcoming-feature",
                     "BestFeature",
                     "-strict-memory-safety",
+                    "-default-isolation", "MainActor",
                     "-g",
                     "-Xcc", "-g",
                     "-Xcc", "-fomit-frame-pointer",
@@ -4506,7 +4510,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
             )
 
             let exe = try result.moduleBuildDescription(for: "exe").swift().compileArguments()
-            XCTAssertMatch(exe, [.anySequence, "-swift-version", "5", "-DFOO", "-g", "-Xcc", "-g", "-Xcc", "-fomit-frame-pointer", .end])
+            XCTAssertMatch(exe, [.anySequence, "-swift-version", "5", "-DFOO", "-default-isolation", "nonisolated", "-g", "-Xcc", "-g", "-Xcc", "-fomit-frame-pointer", .end])
         }
 
         // omit frame pointers explicitly set to false
@@ -4554,6 +4558,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
                     "-enable-upcoming-feature",
                     "BestFeature",
                     "-strict-memory-safety",
+                    "-default-isolation", "MainActor",
                     "-g",
                     "-Xcc", "-g",
                     "-Xcc", "-fno-omit-frame-pointer",
@@ -4562,7 +4567,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
             )
 
             let exe = try result.moduleBuildDescription(for: "exe").swift().compileArguments()
-            XCTAssertMatch(exe, [.anySequence, "-swift-version", "5", "-DFOO", "-g", "-Xcc", "-g", "-Xcc", "-fno-omit-frame-pointer", .end])
+            XCTAssertMatch(exe, [.anySequence, "-swift-version", "5", "-DFOO", "-default-isolation", "nonisolated", "-g", "-Xcc", "-g", "-Xcc", "-fno-omit-frame-pointer", .end])
         }
 
         do {
@@ -4599,6 +4604,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
                     "-enable-upcoming-feature", "BestFeature",
                     "-enable-upcoming-feature", "WorstFeature",
                     "-strict-memory-safety",
+                    "-default-isolation", "MainActor",
                     "-g",
                     "-Xcc", "-g",
                     .end,
@@ -4614,6 +4620,7 @@ class BuildPlanTestCase: BuildSystemProviderTestCase {
                     "-DFOO",
                     "-cxx-interoperability-mode=default",
                     "-Xcc", "-std=c++17",
+                    "-default-isolation", "nonisolated",
                     "-g",
                     "-Xcc", "-g",
                     .end,

Tests/PackageLoadingTests/PackageBuilderTests.swift

@@ -3185,6 +3185,76 @@ final class PackageBuilderTests: XCTestCase {
             }
         }
     }
+
+    func testDefaultIsolationPerTarget() throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Sources/A/a.swift",
+            "/Sources/B/b.swift"
+        )
+
+        let manifest = Manifest.createRootManifest(
+            displayName: "pkg",
+            toolsVersion: .v6_2,
+            targets: [
+                try TargetDescription(
+                    name: "A",
+                    settings: [
+                        .init(tool: .swift, kind: .defaultIsolation(.MainActor))
+                    ]
+                ),
+                try TargetDescription(
+                    name: "B",
+                    settings: [
+                        .init(tool: .swift, kind: .defaultIsolation(.nonisolated), condition: .init(platformNames: ["linux"])),
+                        .init(tool: .swift, kind: .defaultIsolation(.MainActor), condition: .init(platformNames: ["macos"], config: "debug"))
+                    ]
+                ),
+            ]
+        )
+
+        PackageBuilderTester(manifest, in: fs) { package, _ in
+            package.checkModule("A") { package in
+                let macosDebugScope = BuildSettings.Scope(
+                    package.target.buildSettings,
+                    environment: BuildEnvironment(platform: .macOS, configuration: .debug)
+                )
+                XCTAssertMatch(macosDebugScope.evaluate(.OTHER_SWIFT_FLAGS),
+                               [.anySequence, "-default-isolation", "MainActor", .anySequence])
+
+                let macosReleaseScope = BuildSettings.Scope(
+                    package.target.buildSettings,
+                    environment: BuildEnvironment(platform: .macOS, configuration: .release)
+                )
+                XCTAssertMatch(macosReleaseScope.evaluate(.OTHER_SWIFT_FLAGS),
+                               [.anySequence, "-default-isolation", "MainActor", .anySequence])
+
+            }
+
+            package.checkModule("B") { package in
+                let linuxDebugScope = BuildSettings.Scope(
+                    package.target.buildSettings,
+                    environment: BuildEnvironment(platform: .linux, configuration: .debug)
+                )
+                XCTAssertMatch(linuxDebugScope.evaluate(.OTHER_SWIFT_FLAGS),
+                               [.anySequence, "-default-isolation", "nonisolated", .anySequence])
+
+                let macosDebugScope = BuildSettings.Scope(
+                    package.target.buildSettings,
+                    environment: BuildEnvironment(platform: .macOS, configuration: .debug)
+                )
+                XCTAssertMatch(macosDebugScope.evaluate(.OTHER_SWIFT_FLAGS),
+                               [.anySequence, "-default-isolation", "MainActor", .anySequence])
+
+                let macosReleaseScope = BuildSettings.Scope(
+                    package.target.buildSettings,
+                    environment: BuildEnvironment(platform: .macOS, configuration: .release)
+                )
+                XCTAssertNoMatch(macosReleaseScope.evaluate(.OTHER_SWIFT_FLAGS),
+                                 [.anySequence, "-default-isolation", "MainActor", .anySequence])
+
+            }
+        }
+    }
 }
 
 final class PackageBuilderTester {

Tests/WorkspaceTests/ManifestSourceGenerationTests.swift

@@ -858,4 +858,38 @@ final class ManifestSourceGenerationTests: XCTestCase {
         let contents = try manifest.generateManifestFileContents(packageDirectory: manifest.path.parentDirectory)
         try await testManifestWritingRoundTrip(manifestContents: contents, toolsVersion: .v6_0)
     }
+
+    func testDefaultIsolation() async throws {
+        let manifest = Manifest.createRootManifest(
+            displayName: "pkg",
+            path: "/pkg",
+            toolsVersion: .v6_2,
+            dependencies: [],
+            targets: [
+                try TargetDescription(
+                    name: "A",
+                    type: .executable,
+                    settings: [
+                        .init(tool: .swift, kind: .defaultIsolation(.nonisolated))
+                    ]
+                ),
+                try TargetDescription(
+                    name: "B",
+                    type: .executable,
+                    settings: [
+                        .init(tool: .swift, kind: .defaultIsolation(.MainActor))
+                    ]
+                ),
+                try TargetDescription(
+                    name: "conditional",
+                    type: .executable,
+                    settings: [
+                        .init(tool: .swift, kind: .defaultIsolation(.nonisolated), condition: .init(platformNames: ["linux"])),
+                        .init(tool: .swift, kind: .defaultIsolation(.MainActor), condition: .init(platformNames: ["macos"], config: "debug"))
+                    ]
+                )
+            ])
+        let contents = try manifest.generateManifestFileContents(packageDirectory: manifest.path.parentDirectory)
+        try await testManifestWritingRoundTrip(manifestContents: contents, toolsVersion: .v6_2)
+    }
 }