[NFC] Remove SupportedPlatforms, add PlatformVersionProvider

Depends on #7117, unblocks #7160.

The `PackageModel` module has no business of defining supported platforms computation for resolved targets, products, and packages. This belongs to `PackageGraph`, but was previously leaking out into `PackageModel` by passing the `derivedXCTestPlatformProvider` closure around. That prevented us from converting marking `SupportedPlatforms` as `Hashable` and marking any of `Resolved*` types as value types and also `Hashable`. In the future, when we'll also need to make them `Sendable`, this could become problematic, passing so much state captured in a closure, mostly by accident.

Author: MaxDesiatov

Sources/Build/BuildDescription/ProductBuildDescription.swift

@@ -284,7 +284,7 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
             // When deploying to macOS prior to macOS 12, add an rpath to the
             // back-deployed concurrency libraries.
             if useStdlibRpath, self.buildParameters.targetTriple.isMacOSX {
-                let macOSSupportedPlatform = self.package.platforms.getDerived(for: .macOS, usingXCTest: product.isLinkingXCTest)
+                let macOSSupportedPlatform = self.package.getDerived(for: .macOS, usingXCTest: product.isLinkingXCTest)
                 if macOSSupportedPlatform.version.major < 12 {
                     let backDeployedStdlib = try buildParameters.toolchain.macosSwiftStdlib
                         .parentDirectory

Sources/Build/BuildPlan/BuildPlan+Test.swift

@@ -87,7 +87,8 @@ extension BuildPlan {
                     target: discoveryTarget,
                     dependencies: testProduct.targets.map { .target($0, conditions: []) },
                     defaultLocalization: testProduct.defaultLocalization,
-                    platforms: testProduct.platforms
+                    supportedPlatforms: testProduct.supportedPlatforms,
+                    platformVersionProvider: testProduct.platformVersionProvider
                 )
                 let discoveryTargetBuildDescription = try SwiftTargetBuildDescription(
                     package: package,
@@ -120,7 +121,8 @@ extension BuildPlan {
                     target: entryPointTarget,
                     dependencies: testProduct.targets.map { .target($0, conditions: []) } + [.target(discoveryResolvedTarget, conditions: [])],
                     defaultLocalization: testProduct.defaultLocalization,
-                    platforms: testProduct.platforms
+                    supportedPlatforms: testProduct.supportedPlatforms,
+                    platformVersionProvider: testProduct.platformVersionProvider
                 )
                 return try SwiftTargetBuildDescription(
                     package: package,
@@ -149,7 +151,8 @@ extension BuildPlan {
                             target: entryPointTarget,
                             dependencies: entryPointResolvedTarget.dependencies + [.target(discoveryTargets.resolved, conditions: [])],
                             defaultLocalization: testProduct.defaultLocalization,
-                            platforms: testProduct.platforms
+                            supportedPlatforms: testProduct.supportedPlatforms,
+                            platformVersionProvider: testProduct.platformVersionProvider
                         )
                         let entryPointTargetBuildDescription = try SwiftTargetBuildDescription(
                             package: package,

Sources/Build/BuildPlan/BuildPlan.swift

@@ -133,7 +133,7 @@ extension BuildParameters {
         // Compute the triple string for Darwin platform using the platform version.
         if targetTriple.isDarwin() {
             let platform = buildEnvironment.platform
-            let supportedPlatform = target.platforms.getDerived(for: platform, usingXCTest: target.type == .test)
+            let supportedPlatform = target.getDerived(for: platform, usingXCTest: target.type == .test)
             args += [targetTriple.tripleString(forPlatformVersion: supportedPlatform.version.versionString)]
         } else {
             args += [targetTriple.tripleString]
@@ -409,8 +409,8 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
     ) throws {
         // Supported platforms are defined at the package level.
         // This will need to become a bit complicated once we have target-level or product-level platform support.
-        let productPlatform = product.platforms.getDerived(for: .macOS, usingXCTest: product.isLinkingXCTest)
-        let targetPlatform = target.platforms.getDerived(for: .macOS, usingXCTest: target.type == .test)
+        let productPlatform = product.getDerived(for: .macOS, usingXCTest: product.isLinkingXCTest)
+        let targetPlatform = target.getDerived(for: .macOS, usingXCTest: target.type == .test)
 
         // Check if the version requirement is satisfied.
         //

Sources/PackageGraph/CMakeLists.txt

@@ -31,6 +31,7 @@ add_library(PackageGraph
   Resolution/DependencyResolverBinding.swift
   Resolution/DependencyResolverDelegate.swift
   Resolution/DependencyResolverError.swift
+  Resolution/PlatformVersionProvider.swift
   Resolution/ResolvedPackage.swift
   Resolution/ResolvedProduct.swift
   Resolution/ResolvedTarget.swift

Sources/PackageGraph/PackageGraph+Loading.swift

@@ -153,13 +153,9 @@ extension PackageGraph {
             rootManifests: root.manifests,
             unsafeAllowedPackages: unsafeAllowedPackages,
             platformRegistry: customPlatformsRegistry ?? .default,
-            derivedXCTestPlatformProvider: { declared in
-                if let customXCTestMinimumDeploymentTargets {
-                    return customXCTestMinimumDeploymentTargets[declared]
-                } else {
-                    return MinimumDeploymentTarget.default.computeXCTestMinimumDeploymentTarget(for: declared)
-                }
-            },
+            platformVersionProvider: .init(
+                implementation: .customXCTestMinimumDeploymentTargets(customXCTestMinimumDeploymentTargets)
+            ),
             fileSystem: fileSystem,
             observabilityScope: observabilityScope
         )
@@ -240,7 +236,7 @@ private func createResolvedPackages(
     rootManifests: [PackageIdentity: Manifest],
     unsafeAllowedPackages: Set<PackageReference>,
     platformRegistry: PlatformRegistry,
-    derivedXCTestPlatformProvider: @escaping (_ declared: PackageModel.Platform) -> PlatformVersion?,
+    platformVersionProvider: PlatformVersionProvider,
     fileSystem: FileSystem,
     observabilityScope: ObservabilityScope
 ) throws -> [ResolvedPackage] {
@@ -257,7 +253,8 @@ private func createResolvedPackages(
             package,
             productFilter: node.productFilter,
             isAllowedToVendUnsafeProducts: isAllowedToVendUnsafeProducts,
-            allowedToOverride: allowedToOverride
+            allowedToOverride: allowedToOverride,
+            platformVersionProvider: platformVersionProvider
         )
     }
 
@@ -361,14 +358,19 @@ private func createResolvedPackages(
 
         packageBuilder.defaultLocalization = package.manifest.defaultLocalization
 
-        packageBuilder.platforms = computePlatforms(
+        packageBuilder.supportedPlatforms = computePlatforms(
             package: package,
-            platformRegistry: platformRegistry,
-            derivedXCTestPlatformProvider: derivedXCTestPlatformProvider
+            platformRegistry: platformRegistry
         )
 
         // Create target builders for each target in the package.
-        let targetBuilders = package.targets.map{ ResolvedTargetBuilder(target: $0, observabilityScope: packageObservabilityScope) }
+        let targetBuilders = package.targets.map {
+            ResolvedTargetBuilder(
+                target: $0,
+                observabilityScope: packageObservabilityScope,
+                platformVersionProvider: platformVersionProvider
+            )
+        }
         packageBuilder.targets = targetBuilders
 
         // Establish dependencies between the targets. A target can only depend on another target present in the same package.
@@ -386,7 +388,7 @@ private func createResolvedPackages(
                 }
             }
             targetBuilder.defaultLocalization = packageBuilder.defaultLocalization
-            targetBuilder.platforms = packageBuilder.platforms
+            targetBuilder.supportedPlatforms = packageBuilder.supportedPlatforms
         }
 
         // Create product builders for each product in the package. A product can only contain a target present in the same package.
@@ -743,10 +745,8 @@ private class DuplicateProductsChecker {
 
 private func computePlatforms(
     package: Package,
-    platformRegistry: PlatformRegistry,
-    derivedXCTestPlatformProvider: @escaping (_ declared: PackageModel.Platform) -> PlatformVersion?
-) -> SupportedPlatforms {
-
+    platformRegistry: PlatformRegistry
+) -> [SupportedPlatform] {
     // the supported platforms as declared in the manifest
     let declaredPlatforms: [SupportedPlatform] = package.manifest.platforms.map { platform in
         let declaredPlatform = platformRegistry.platformByName[platform.platformName]
@@ -758,10 +758,7 @@ private func computePlatforms(
         )
     }
 
-    return SupportedPlatforms(
-        declared: declaredPlatforms.sorted(by: { $0.platform.name < $1.platform.name }),
-        derivedXCTestPlatformProvider: derivedXCTestPlatformProvider
-    )
+    return declaredPlatforms.sorted(by: { $0.platform.name < $1.platform.name })
 }
 
 // Track and override module aliases specified for targets in a package graph
@@ -888,18 +885,22 @@ private final class ResolvedTargetBuilder: ResolvedBuilder<ResolvedTarget> {
     var defaultLocalization: String? = nil
 
     /// The platforms supported by this package.
-    var platforms: SupportedPlatforms = .init(declared: [], derivedXCTestPlatformProvider: .none)
+    var supportedPlatforms: [SupportedPlatform] = []
+
+    let platformVersionProvider: PlatformVersionProvider
 
     init(
         target: Target,
-        observabilityScope: ObservabilityScope
+        observabilityScope: ObservabilityScope,
+        platformVersionProvider: PlatformVersionProvider
     ) {
         self.target = target
         self.diagnosticsEmitter = observabilityScope.makeDiagnosticsEmitter() {
             var metadata = ObservabilityMetadata()
             metadata.targetName = target.name
             return metadata
         }
+        self.platformVersionProvider = platformVersionProvider
     }
 
     func diagnoseInvalidUseOfUnsafeFlags(_ product: ResolvedProduct) throws {
@@ -934,7 +935,8 @@ private final class ResolvedTargetBuilder: ResolvedBuilder<ResolvedTarget> {
             target: self.target,
             dependencies: dependencies,
             defaultLocalization: self.defaultLocalization,
-            platforms: self.platforms
+            supportedPlatforms: self.supportedPlatforms,
+            platformVersionProvider: self.platformVersionProvider
         )
     }
 }
@@ -983,27 +985,37 @@ private final class ResolvedPackageBuilder: ResolvedBuilder<ResolvedPackage> {
     var defaultLocalization: String? = nil
 
     /// The platforms supported by this package.
-    var platforms: SupportedPlatforms = .init(declared: [], derivedXCTestPlatformProvider: .none)
+    var supportedPlatforms: [SupportedPlatform] = []
 
     /// If the given package's source is a registry release, this provides additional metadata and signature information.
     var registryMetadata: RegistryReleaseMetadata?
 
-    init(_ package: Package, productFilter: ProductFilter, isAllowedToVendUnsafeProducts: Bool, allowedToOverride: Bool) {
+    let platformVersionProvider: PlatformVersionProvider
+
+    init(
+        _ package: Package,
+        productFilter: ProductFilter,
+        isAllowedToVendUnsafeProducts: Bool,
+        allowedToOverride: Bool,
+        platformVersionProvider: PlatformVersionProvider
+    ) {
         self.package = package
         self.productFilter = productFilter
         self.isAllowedToVendUnsafeProducts = isAllowedToVendUnsafeProducts
         self.allowedToOverride = allowedToOverride
+        self.platformVersionProvider = platformVersionProvider
     }
 
     override func constructImpl() throws -> ResolvedPackage {
         return ResolvedPackage(
             package: self.package,
             defaultLocalization: self.defaultLocalization,
-            platforms: self.platforms,
+            supportedPlatforms: self.supportedPlatforms,
             dependencies: try self.dependencies.map{ try $0.construct() },
             targets: try self.targets.map{ try $0.construct() },
             products: try self.products.map{ try $0.construct() },
-            registryMetadata: self.registryMetadata
+            registryMetadata: self.registryMetadata,
+            platformVersionProvider: self.platformVersionProvider
         )
     }
 }

Sources/PackageGraph/Resolution/PlatformVersionProvider.swift

@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2014-2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import struct PackageModel.MinimumDeploymentTarget
+import struct PackageModel.Platform
+import struct PackageModel.PlatformVersion
+import struct PackageModel.SupportedPlatform
+
+/// Merging two sets of supported platforms, preferring the max constraint
+func merge(into partial: inout [SupportedPlatform], platforms: [SupportedPlatform]) {
+    for platformSupport in platforms {
+        if let existing = partial.firstIndex(where: { $0.platform == platformSupport.platform }) {
+            if partial[existing].version < platformSupport.version {
+                partial.remove(at: existing)
+                partial.append(platformSupport)
+            }
+        } else {
+            partial.append(platformSupport)
+        }
+    }
+}
+
+public struct PlatformVersionProvider: Hashable {
+    public enum Implementation: Hashable {
+        case mergingFromTargets([ResolvedTarget])
+        case customXCTestMinimumDeploymentTargets([PackageModel.Platform: PlatformVersion]?)
+        case empty
+    }
+
+    private let implementation: Implementation
+
+    public init(implementation: Implementation) {
+        self.implementation = implementation
+    }
+
+    func derivedXCTestPlatformProvider(_ declared: PackageModel.Platform) -> PlatformVersion? {
+        switch implementation {
+        case .mergingFromTargets(let targets):
+            let platforms = targets.reduce(into: [SupportedPlatform]()) { partial, item in
+                merge(into: &partial, platforms: [item.getDerived(for: declared, usingXCTest: item.type == .test)])
+            }
+            return platforms.first!.version
+
+        case .customXCTestMinimumDeploymentTargets(let customXCTestMinimumDeploymentTargets):
+            if let customXCTestMinimumDeploymentTargets {
+                return customXCTestMinimumDeploymentTargets[declared]
+            } else {
+                return MinimumDeploymentTarget.default.computeXCTestMinimumDeploymentTarget(for: declared)
+            }
+
+        case .empty:
+            return nil
+        }
+    }
+
+    /// Returns the supported platform instance for the given platform.
+    func getDerived(declared: [SupportedPlatform], for platform: Platform, usingXCTest: Bool) -> SupportedPlatform {
+        // derived platform based on known minimum deployment target logic
+        if let declaredPlatform = declared.first(where: { $0.platform == platform }) {
+            var version = declaredPlatform.version
+
+            if usingXCTest, let xcTestMinimumDeploymentTarget = self.derivedXCTestPlatformProvider(platform), version < xcTestMinimumDeploymentTarget {
+                version = xcTestMinimumDeploymentTarget
+            }
+
+            // If the declared version is smaller than the oldest supported one, we raise the derived version to that.
+            if version < platform.oldestSupportedVersion {
+                version = platform.oldestSupportedVersion
+            }
+
+            return SupportedPlatform(
+                platform: declaredPlatform.platform,
+                version: version,
+                options: declaredPlatform.options
+            )
+        } else {
+            let minimumSupportedVersion: PlatformVersion
+            if usingXCTest, let xcTestMinimumDeploymentTarget = self.derivedXCTestPlatformProvider(platform), xcTestMinimumDeploymentTarget > platform.oldestSupportedVersion {
+                minimumSupportedVersion = xcTestMinimumDeploymentTarget
+            } else {
+                minimumSupportedVersion = platform.oldestSupportedVersion
+            }
+
+            let oldestSupportedVersion: PlatformVersion
+            if platform == .macCatalyst {
+                let iOS = self.getDerived(declared: declared, for: .iOS, usingXCTest: usingXCTest)
+                // If there was no deployment target specified for Mac Catalyst, fall back to the iOS deployment target.
+                oldestSupportedVersion = max(minimumSupportedVersion, iOS.version)
+            } else {
+                oldestSupportedVersion = minimumSupportedVersion
+            }
+
+            return SupportedPlatform(
+                platform: platform,
+                version: oldestSupportedVersion,
+                options: []
+            )
+        }
+    }
+}

Sources/PackageGraph/Resolution/ResolvedPackage.swift

@@ -46,27 +46,39 @@ public final class ResolvedPackage {
     public let defaultLocalization: String?
 
     /// The list of platforms that are supported by this target.
-    public let platforms: SupportedPlatforms
+    public let supportedPlatforms: [SupportedPlatform]
 
     /// If the given package's source is a registry release, this provides additional metadata and signature information.
     public let registryMetadata: RegistryReleaseMetadata?
 
+    private let platformVersionProvider: PlatformVersionProvider
+
     public init(
         package: Package,
         defaultLocalization: String?,
-        platforms: SupportedPlatforms,
+        supportedPlatforms: [SupportedPlatform],
         dependencies: [ResolvedPackage],
         targets: [ResolvedTarget],
         products: [ResolvedProduct],
-        registryMetadata: RegistryReleaseMetadata?
+        registryMetadata: RegistryReleaseMetadata?,
+        platformVersionProvider: PlatformVersionProvider
     ) {
         self.underlyingPackage = package
         self.defaultLocalization = defaultLocalization
-        self.platforms = platforms
+        self.supportedPlatforms = supportedPlatforms
         self.dependencies = dependencies
         self.targets = targets
         self.products = products
         self.registryMetadata = registryMetadata
+        self.platformVersionProvider = platformVersionProvider
+    }    
+
+    public func getDerived(for platform: Platform, usingXCTest: Bool) -> SupportedPlatform {
+        self.platformVersionProvider.getDerived(
+            declared: self.supportedPlatforms,
+            for: platform,
+            usingXCTest: usingXCTest
+        )
     }
 }