[Package/Build] Remove toolsSwiftVersion from SwiftTarget in favor of a build setting

Start using "default" assignments to represent tools version
based swift language version setting that is going to be produced
by `BuildSettings.Scope` if no other assignments match build
environment conditions.

This removes ambiguity from `-swift-version` selection for
downstream clients.

Author: xedin

Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift

@@ -146,11 +146,6 @@ package final class SwiftTargetBuildDescription {
     /// Any addition flags to be added. These flags are expected to be computed during build planning.
     var additionalFlags: [String] = []
 
-    /// The swift language version that is computed for this target based on tools version of the manifest.
-    var toolsSwiftVersion: SwiftLanguageVersion {
-        self.swiftTarget.toolSwiftVersion
-    }
-
     /// Describes the purpose of a test target, including any special roles such as containing a list of discovered
     /// tests or serving as the manifest target which contains the main entry point.
     package enum TestTargetRole {
@@ -580,11 +575,6 @@ package final class SwiftTargetBuildDescription {
         // Add arguments from declared build settings.
         args += try self.buildSettingsFlags()
 
-        // Fallback to package wide setting if there is no target specific version.
-        if args.firstIndex(of: "-swift-version") == nil {
-            args += ["-swift-version", self.toolsSwiftVersion.rawValue]
-        }
-
         // Add the output for the `.swiftinterface`, if requested or if library evolution has been enabled some other
         // way.
         if self.defaultBuildParameters.driverParameters.enableParseableModuleInterfaces || args.contains("-enable-library-evolution") {

Sources/Build/BuildPlan/BuildPlan+Test.swift

@@ -268,7 +268,6 @@ private extension PackageModel.SwiftTarget {
             sources: sources,
             dependencies: dependencies,
             packageAccess: packageAccess,
-            toolsSwiftVersion: .v5,
             usesUnsafeFlags: false
         )
     }

Sources/PackageLoading/PackageBuilder.swift

@@ -906,7 +906,8 @@ public final class PackageBuilder {
         let buildSettings = try self.buildSettings(
             for: manifestTarget,
             targetRoot: potentialModule.path,
-            cxxLanguageStandard: self.manifest.cxxLanguageStandard
+            cxxLanguageStandard: self.manifest.cxxLanguageStandard,
+            toolsSwiftVersion: self.toolsSwiftVersion()
         )
 
         // Compute the path to public headers directory.
@@ -997,7 +998,6 @@ public final class PackageBuilder {
                 others: others,
                 dependencies: dependencies,
                 packageAccess: potentialModule.packageAccess,
-                toolsSwiftVersion: self.toolsSwiftVersion(),
                 declaredSwiftVersions: self.declaredSwiftVersions(),
                 buildSettings: buildSettings,
                 buildSettingsDescription: manifestTarget.settings,
@@ -1055,11 +1055,18 @@ public final class PackageBuilder {
     func buildSettings(
         for target: TargetDescription?,
         targetRoot: AbsolutePath,
-        cxxLanguageStandard: String? = nil
+        cxxLanguageStandard: String? = nil,
+        toolsSwiftVersion: SwiftLanguageVersion
     ) throws -> BuildSettings.AssignmentTable {
         var table = BuildSettings.AssignmentTable()
         guard let target else { return table }
 
+        // First let's add a default assignments for tools swift version.
+        var versionAssignment = BuildSettings.Assignment(default: true)
+        versionAssignment.values = [toolsSwiftVersion.rawValue]
+
+        table.add(versionAssignment, for: .SWIFT_VERSION)
+
         // Process each setting.
         for setting in target.settings {
             let decl: BuildSettings.Declaration
@@ -1728,17 +1735,17 @@ extension PackageBuilder {
                 )
                 buildSettings = try self.buildSettings(
                     for: targetDescription,
-                    targetRoot: sourceFile.parentDirectory
+                    targetRoot: sourceFile.parentDirectory,
+                    toolsSwiftVersion: self.toolsSwiftVersion()
                 )
 
-                return try SwiftTarget(
+                return SwiftTarget(
                     name: name,
                     type: .snippet,
                     path: .root,
                     sources: sources,
                     dependencies: dependencies,
                     packageAccess: false,
-                    toolsSwiftVersion: self.toolsSwiftVersion(),
                     buildSettings: buildSettings,
                     buildSettingsDescription: targetDescription.settings,
                     usesUnsafeFlags: false

Sources/PackageModel/Target/SwiftTarget.swift

@@ -23,7 +23,6 @@ public final class SwiftTarget: Target {
     }
 
     public init(name: String, dependencies: [Target.Dependency], packageAccess: Bool, testDiscoverySrc: Sources) {
-        self.toolSwiftVersion = .v5
         self.declaredSwiftVersions = []
 
         super.init(
@@ -40,9 +39,6 @@ public final class SwiftTarget: Target {
         )
     }
 
-    /// The swift language version that is computed for this target based on tools version of the manifest.
-    public let toolSwiftVersion: SwiftLanguageVersion
-
     /// The list of swift versions declared by the manifest.
     public let declaredSwiftVersions: [SwiftLanguageVersion]
 
@@ -57,14 +53,12 @@ public final class SwiftTarget: Target {
         others: [AbsolutePath] = [],
         dependencies: [Target.Dependency] = [],
         packageAccess: Bool,
-        toolsSwiftVersion: SwiftLanguageVersion,
         declaredSwiftVersions: [SwiftLanguageVersion] = [],
         buildSettings: BuildSettings.AssignmentTable = .init(),
         buildSettingsDescription: [TargetBuildSettingDescription.Setting] = [],
         pluginUsages: [PluginUsage] = [],
         usesUnsafeFlags: Bool
     ) {
-        self.toolSwiftVersion = toolsSwiftVersion
         self.declaredSwiftVersions = declaredSwiftVersions
         super.init(
             name: name,
@@ -99,12 +93,22 @@ public final class SwiftTarget: Target {
             return target.type == .test
         }.flatMap { $0.target as? SwiftTarget }
 
-        // FIXME: This is not very correct but doesn't matter much in practice.
         // We need to select the latest Swift language version that can
         // satisfy the current tools version but there is not a good way to
         // do that currently.
-        self.toolSwiftVersion = swiftTestTarget?
-            .toolSwiftVersion ?? SwiftLanguageVersion(string: String(SwiftVersion.current.major)) ?? .v4
+        var buildSettings: BuildSettings.AssignmentTable = .init()
+        do {
+            let toolsSwiftVersion = swiftTestTarget?.buildSettings.assignments[.SWIFT_VERSION]?
+                .filter(\.default)
+                .filter(\.conditions.isEmpty)
+                .flatMap(\.values)
+
+            var versionAssignment = BuildSettings.Assignment()
+            versionAssignment.values = toolsSwiftVersion ?? [String(SwiftVersion.current.major)]
+
+            buildSettings.add(versionAssignment, for: .SWIFT_VERSION)
+        }
+
         self.declaredSwiftVersions = []
         let sources = Sources(paths: [testEntryPointPath], root: testEntryPointPath.parentDirectory)
 
@@ -115,28 +119,25 @@ public final class SwiftTarget: Target {
             sources: sources,
             dependencies: dependencies,
             packageAccess: packageAccess,
-            buildSettings: .init(),
+            buildSettings: buildSettings,
             buildSettingsDescription: [],
             pluginUsages: [],
             usesUnsafeFlags: false
         )
     }
 
     private enum CodingKeys: String, CodingKey {
-        case swiftVersion
         case declaredSwiftVersions
     }
 
     override public func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
-        try container.encode(self.toolSwiftVersion, forKey: .swiftVersion)
         try container.encode(self.declaredSwiftVersions, forKey: .declaredSwiftVersions)
         try super.encode(to: encoder)
     }
 
     public required init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
-        self.toolSwiftVersion = try container.decode(SwiftLanguageVersion.self, forKey: .swiftVersion)
         self.declaredSwiftVersions = try container.decode([SwiftLanguageVersion].self, forKey: .declaredSwiftVersions)
         try super.init(from: decoder)
     }

Sources/SPMTestSupport/ResolvedTarget+Mock.swift

@@ -29,7 +29,6 @@ extension ResolvedModule {
                 sources: Sources(paths: [], root: "/"),
                 dependencies: [],
                 packageAccess: false,
-                toolsSwiftVersion: .v4,
                 usesUnsafeFlags: false
             ),
             dependencies: deps.map { .target($0, conditions: conditions) },

Tests/BuildTests/BuildPlanTests.swift

@@ -4068,13 +4068,13 @@ final class BuildPlanTests: XCTestCase {
                 bar,
                 [
                     .anySequence,
+                    "-swift-version", "5",
                     "-DLINUX",
                     "-Isfoo",
                     "-L", "sbar",
                     "-cxx-interoperability-mode=default",
                     "-Xcc", "-std=c++17",
                     "-enable-upcoming-feature", "BestFeature",
-                    "-swift-version", "5",
                     "-g",
                     "-Xcc", "-g",
                     "-Xcc", "-fno-omit-frame-pointer",
@@ -4133,14 +4133,14 @@ final class BuildPlanTests: XCTestCase {
                 bar,
                 [
                     .anySequence,
+                    "-swift-version", "5",
                     "-DLINUX",
                     "-Isfoo",
                     "-L", "sbar",
                     "-cxx-interoperability-mode=default",
                     "-Xcc", "-std=c++17",
                     "-enable-upcoming-feature",
                     "BestFeature",
-                    "-swift-version", "5",
                     "-g",
                     "-Xcc", "-g",
                     "-Xcc", "-fomit-frame-pointer",
@@ -4190,14 +4190,14 @@ final class BuildPlanTests: XCTestCase {
                 bar,
                 [
                     .anySequence,
+                    "-swift-version", "5",
                     "-DLINUX",
                     "-Isfoo",
                     "-L", "sbar",
                     "-cxx-interoperability-mode=default",
                     "-Xcc", "-std=c++17",
                     "-enable-upcoming-feature",
                     "BestFeature",
-                    "-swift-version", "5",
                     "-g",
                     "-Xcc", "-g",
                     "-Xcc", "-fno-omit-frame-pointer",
@@ -4234,14 +4234,14 @@ final class BuildPlanTests: XCTestCase {
                 bar,
                 [
                     .anySequence,
+                    "-swift-version", "5",
                     "-DDMACOS",
                     "-Isfoo",
                     "-L", "sbar",
                     "-cxx-interoperability-mode=default",
                     "-Xcc", "-std=c++17",
                     "-enable-upcoming-feature", "BestFeature",
                     "-enable-upcoming-feature", "WorstFeature",
-                    "-swift-version", "5",
                     "-g",
                     "-Xcc", "-g",
                     .end,

Tests/PackageLoadingTests/PackageBuilderTests.swift

@@ -3012,8 +3012,12 @@ final class PackageBuilderTests: XCTestCase {
         assignment.values = ["YOLO"]
         assignment.conditions = [PackageCondition(platforms: [.custom(name: "bestOS", oldestSupportedVersion: .unknown)])]
 
+        var versionAssignment = BuildSettings.Assignment(default: true)
+        versionAssignment.values = ["4"]
+
         var settings = BuildSettings.AssignmentTable()
         settings.add(assignment, for: .SWIFT_ACTIVE_COMPILATION_CONDITIONS)
+        settings.add(versionAssignment, for: .SWIFT_VERSION)
 
         PackageBuilderTester(manifest, in: fs) { package, _ in
             package.checkModule("Foo") { module in
@@ -3081,7 +3085,7 @@ final class PackageBuilderTests: XCTestCase {
                     package.target.buildSettings,
                     environment: BuildEnvironment(platform: .macOS, configuration: .release)
                 )
-                XCTAssertEqual(macosReleaseScope.evaluate(.SWIFT_VERSION), [])
+                XCTAssertEqual(macosReleaseScope.evaluate(.SWIFT_VERSION), ["5"])
             }
         }
     }
@@ -3303,7 +3307,9 @@ final class PackageBuilderTester {
             guard case let swiftTarget as SwiftTarget = target else {
                 return XCTFail("\(target) is not a swift target", file: file, line: line)
             }
-            XCTAssertEqual(SwiftLanguageVersion(string: swiftVersion)!, swiftTarget.toolSwiftVersion, file: file, line: line)
+            let versionAssignments = swiftTarget.buildSettings.assignments[.SWIFT_VERSION]?
+                .filter { $0.conditions.isEmpty }.flatMap(\.values)
+            XCTAssertNotNil(versionAssignments?.contains(swiftVersion), file: file, line: line)
         }
 
         func check(pluginCapability: PluginCapability, file: StaticString = #file, line: UInt = #line) {