Verify product dependencies w/ target platform, vs. hardcoded macOS (#6963)

Product dependencies are now verified using the `buildEnvironment`'s
platform, instead of the hardcoded `macOS` platform.

This builds on the work of #6732, now allowing cross-compilation of
product dependencies 🎉

### Motivation:
Let's say we're cross-compiling macOS -> iOS simulator, with a host
system of `macOS v13`.
```swift
let package = Package(
    name: "SwiftFlashlight",
    products: [.library(...)],
    platforms: [.iOS(.v16)],
    dependencies: [
        // internally, for iOS(.v16), macOS(.v14)
        .package(url: "probably/alamofire", exact: "1.2.3")
    ],
    // ...
)
```

As long as we set our triple & SDK, we _should_ be good... (and, with
#6828, only the triple needed)
```fish
> swift build --triple arm64-apple-ios-simulator \
              --sdk "$(xcrun --sdk iphonesimulator --show-sdk-path)"
...
error: the library 'SwiftFlashlight' requires macos 10.13,
but depends on the product 'probably/alamofire' which requires macos 10.14;  [...]
```

Even though `SwiftFlashlight` only supports `iOS(.v16)`,
[SupportedPlatform](https://github.com/apple/swift-package-manager/blob/main/Documentation/PackageDescription.md#supportedplatform)
"[by] default, [...] assigns a predefined minimum deployment version for
each supported platforms unless you configure supported platforms
[...]". As a side-effect, `macOS` is inferred as a valid platform. (This
is why no "target/platform mismatch" error was thrown.)

Previously, product dependencies were verified against `macOS`, rather
than the target platform. Since `macOS` is always inferred, this
surfaced as a "woah! your dependencies are out of sync".

```swift

let swiftFlashlight = Package(
    platforms: [
        .iOS(.v16),
        .macOS(.v13) // <-- inferred-|
    ],                               |
)                                    |-- // since --triple is .iOS,
                                     |   // shouldn't be comparing
let probably/alamofire = Package (   |   // macOS.
    platforms: [                     |
        iOS(.v16),                   |
        macOS(.v14)] // <-- inferred-|
    ]
)
```

Now, the intention of `--triple` is respected 🐱

### Modifications:
- `validateDeploymentVersionOfProductDependency` accepts a
`buildEnvironment` containing the target platform

### Result:

Product dependencies can now be compiled for `darwin` other than macOS
-- i.e, iOS :)

### Future work

- Target-level or product-level platform support is still up in the air
- This only applies to `triple.isDarwin()` -- perhaps a next step of
verifying dependencies against non-darwin?

---------

Co-authored-by: Max Desiatov <[email protected]>

Author: peterkos

Sources/Build/BuildPlan/BuildPlan.swift

@@ -32,11 +32,11 @@ import var TSCUtility.verbosity
 
 extension String {
     var asSwiftStringLiteralConstant: String {
-        return unicodeScalars.reduce("", { $0 + $1.escaped(asASCII: false) })
+        unicodeScalars.reduce("") { $0 + $1.escaped(asASCII: false) }
     }
 }
 
-extension Array where Element == String {
+extension [String] {
     /// Converts a set of C compiler flags into an equivalent set to be
     /// indirected through the Swift compiler instead.
     func asSwiftcCCompilerFlags() -> Self {
@@ -142,7 +142,8 @@ extension BuildParameters {
         return args
     }
 
-    /// Computes the linker flags to use in order to rename a module-named main function to 'main' for the target platform, or nil if the linker doesn't support it for the platform.
+    /// Computes the linker flags to use in order to rename a module-named main function to 'main' for the target
+    /// platform, or nil if the linker doesn't support it for the platform.
     func linkerFlagsForRenamingMainFunction(of target: ResolvedTarget) -> [String]? {
         let args: [String]
         if self.triple.isApple() {
@@ -209,12 +210,12 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
 
     /// The build targets.
     public var targets: AnySequence<TargetBuildDescription> {
-        return AnySequence(targetMap.values)
+        AnySequence(self.targetMap.values)
     }
 
     /// The products in this plan.
     public var buildProducts: AnySequence<SPMBuildCore.ProductBuildDescription> {
-        return AnySequence(productMap.values.map { $0 as SPMBuildCore.ProductBuildDescription })
+        AnySequence(self.productMap.values.map { $0 as SPMBuildCore.ProductBuildDescription })
     }
 
     /// The results of invoking any build tool plugins used by targets in this build.
@@ -313,11 +314,12 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
                 observabilityScope: observabilityScope
             )
         }
-        let macroProductsByTarget = productMap.keys.filter { $0.type == .macro }.reduce(into: [ResolvedTarget: ResolvedProduct]()) {
-            if let target = $1.targets.first {
-                $0[target] = $1
+        let macroProductsByTarget = productMap.keys.filter { $0.type == .macro }
+            .reduce(into: [ResolvedTarget: ResolvedProduct]()) {
+                if let target = $1.targets.first {
+                    $0[target] = $1
+                }
             }
-        }
 
         // Create build target description for each target which we need to plan.
         // Plugin targets are noted, since they need to be compiled, but they do
@@ -348,6 +350,7 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
                         try BuildPlan.validateDeploymentVersionOfProductDependency(
                             product: product,
                             forTarget: target,
+                            buildEnvironment: buildParameters.buildEnvironment,
                             observabilityScope: self.observabilityScope
                         )
                     }
@@ -372,45 +375,50 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
                     shouldGenerateTestObservation = false // Only generate the code once.
                 }
 
-                targetMap[target] = try .swift(SwiftTargetBuildDescription(
-                    package: package,
-                    target: target,
-                    toolsVersion: toolsVersion,
-                    additionalFileRules: additionalFileRules,
-                    buildParameters: buildParameters,
-                    buildToolPluginInvocationResults: buildToolPluginInvocationResults[target] ?? [],
-                    prebuildCommandResults: prebuildCommandResults[target] ?? [],
-                    requiredMacroProducts: requiredMacroProducts,
-                    shouldGenerateTestObservation: generateTestObservation,
-                    disableSandbox: self.disableSandbox,
-                    fileSystem: fileSystem,
-                    observabilityScope: observabilityScope)
+                targetMap[target] = try .swift(
+                    SwiftTargetBuildDescription(
+                        package: package,
+                        target: target,
+                        toolsVersion: toolsVersion,
+                        additionalFileRules: additionalFileRules,
+                        buildParameters: buildParameters,
+                        buildToolPluginInvocationResults: buildToolPluginInvocationResults[target] ?? [],
+                        prebuildCommandResults: prebuildCommandResults[target] ?? [],
+                        requiredMacroProducts: requiredMacroProducts,
+                        shouldGenerateTestObservation: generateTestObservation,
+                        disableSandbox: self.disableSandbox,
+                        fileSystem: fileSystem,
+                        observabilityScope: observabilityScope
+                    )
                 )
             case is ClangTarget:
-                targetMap[target] = try .clang(ClangTargetBuildDescription(
-                    target: target,
-                    toolsVersion: toolsVersion,
-                    additionalFileRules: additionalFileRules,
-                    buildParameters: buildParameters,
-                    buildToolPluginInvocationResults: buildToolPluginInvocationResults[target] ?? [],
-                    prebuildCommandResults: prebuildCommandResults[target] ?? [],
-                    fileSystem: fileSystem,
-                    observabilityScope: observabilityScope)
+                targetMap[target] = try .clang(
+                    ClangTargetBuildDescription(
+                        target: target,
+                        toolsVersion: toolsVersion,
+                        additionalFileRules: additionalFileRules,
+                        buildParameters: buildParameters,
+                        buildToolPluginInvocationResults: buildToolPluginInvocationResults[target] ?? [],
+                        prebuildCommandResults: prebuildCommandResults[target] ?? [],
+                        fileSystem: fileSystem,
+                        observabilityScope: observabilityScope
+                    )
                 )
             case is PluginTarget:
                 guard let package = graph.package(for: target) else {
                     throw InternalError("package not found for \(target)")
                 }
                 try pluginDescriptions.append(PluginDescription(
                     target: target,
-                    products: package.products.filter{ $0.targets.contains(target) },
+                    products: package.products.filter { $0.targets.contains(target) },
                     package: package,
                     toolsVersion: toolsVersion,
-                    fileSystem: fileSystem))
+                    fileSystem: fileSystem
+                ))
             case is SystemLibraryTarget, is BinaryTarget:
-                 break
+                break
             default:
-                 throw InternalError("unhandled \(target.underlying)")
+                throw InternalError("unhandled \(target.underlying)")
             }
         }
 
@@ -443,7 +451,7 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
                     derivedTestTargets.append(discoveryTargetBuildDescription.target)
                 }
 
-                derivedTestTargetsMap[item.product] = derivedTestTargets
+                self.derivedTestTargetsMap[item.product] = derivedTestTargets
             }
         }
 
@@ -452,18 +460,25 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         self.pluginDescriptions = pluginDescriptions
 
         // Finally plan these targets.
-        try plan()
+        try self.plan()
     }
 
     static func validateDeploymentVersionOfProductDependency(
         product: ResolvedProduct,
         forTarget target: ResolvedTarget,
+        buildEnvironment: BuildEnvironment,
         observabilityScope: ObservabilityScope
     ) throws {
-        // Supported platforms are defined at the package level.
+        // Supported platforms are defined at the package (e.g., build environment) level.
         // This will need to become a bit complicated once we have target-level or product-level platform support.
-        let productPlatform = product.getSupportedPlatform(for: .macOS, usingXCTest: product.isLinkingXCTest)
-        let targetPlatform = target.getSupportedPlatform(for: .macOS, usingXCTest: target.type == .test)
+        let productPlatform = product.getSupportedPlatform(
+            for: buildEnvironment.platform,
+            usingXCTest: product.isLinkingXCTest
+        )
+        let targetPlatform = target.getSupportedPlatform(
+            for: buildEnvironment.platform,
+            usingXCTest: target.type == .test
+        )
 
         // Check if the version requirement is satisfied.
         //
@@ -481,7 +496,7 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
     /// Plan the targets and products.
     private func plan() throws {
         // Plan targets.
-        for buildTarget in targets {
+        for buildTarget in self.targets {
             switch buildTarget {
             case .swift(let target):
                 try self.plan(swiftTarget: target)
@@ -491,8 +506,8 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         }
 
         // Plan products.
-        for buildProduct in buildProducts {
-            try plan(buildProduct: buildProduct as! ProductBuildDescription)
+        for buildProduct in self.buildProducts {
+            try self.plan(buildProduct: buildProduct as! ProductBuildDescription)
         }
         // FIXME: We need to find out if any product has a target on which it depends
         // both static and dynamically and then issue a suitable diagnostic or auto
@@ -523,7 +538,7 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         arguments += extraSwiftCFlags
 
         // Add search paths to the directories containing module maps and Swift modules.
-        for target in targets {
+        for target in self.targets {
             switch target {
             case .swift(let targetDescription):
                 arguments += ["-I", targetDescription.moduleOutputPath.parentDirectory.pathString]
@@ -553,16 +568,16 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         var arguments = ["repl", "-I" + buildPath, "-L" + buildPath]
 
         // Link the special REPL product that contains all of the library targets.
-        let replProductName = graph.rootPackages[0].identity.description + Product.replProductSuffix
+        let replProductName = self.graph.rootPackages[0].identity.description + Product.replProductSuffix
         arguments.append("-l" + replProductName)
 
         // The graph should have the REPL product.
-        assert(graph.allProducts.first(where: { $0.name == replProductName }) != nil)
+        assert(self.graph.allProducts.first(where: { $0.name == replProductName }) != nil)
 
         // Add the search path to the directory containing the modulemap file.
-        for target in targets {
+        for target in self.targets {
             switch target {
-                case .swift: break
+            case .swift: break
             case .clang(let targetDescription):
                 if let includeDir = targetDescription.moduleMap?.parentDirectory {
                     arguments += ["-I\(includeDir.pathString)"]
@@ -585,16 +600,15 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         // If we already have these flags, we're done.
         if let flags = pkgConfigCache[target] {
             return flags
-        }
-        else {
-            pkgConfigCache[target] = ([], [])
+        } else {
+            self.pkgConfigCache[target] = ([], [])
         }
         let results = try pkgConfigArgs(
             for: target,
             pkgConfigDirectories: self.destinationBuildParameters.pkgConfigDirectories,
             sdkRootPath: self.destinationBuildParameters.toolchain.sdkRootPath,
-            fileSystem: fileSystem,
-            observabilityScope: observabilityScope
+            fileSystem: self.fileSystem,
+            observabilityScope: self.observabilityScope
         )
         var ret: [(cFlags: [String], libs: [String])] = []
         for result in results {
@@ -613,21 +627,23 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         }
 
         let result = ([String](cflagsCache), libsCache)
-        pkgConfigCache[target] = result
+        self.pkgConfigCache[target] = result
         return result
     }
 
     /// Extracts the library information from an XCFramework.
     func parseXCFramework(for binaryTarget: BinaryTarget, triple: Basics.Triple) throws -> [LibraryInfo] {
         try self.externalLibrariesCache.memoize(key: binaryTarget) {
-            return try binaryTarget.parseXCFrameworks(for: triple, fileSystem: self.fileSystem)
+            try binaryTarget.parseXCFrameworks(for: triple, fileSystem: self.fileSystem)
         }
     }
 }
 
 extension Basics.Diagnostic {
     static var swiftBackDeployError: Self {
-        .warning("Swift compiler no longer supports statically linking the Swift libraries. They're included in the OS by default starting with macOS Mojave 10.14.4 beta 3. For macOS Mojave 10.14.3 and earlier, there's an optional Swift library package that can be downloaded from \"More Downloads\" for Apple Developers at https://developer.apple.com/download/more/")
+        .warning(
+            "Swift compiler no longer supports statically linking the Swift libraries. They're included in the OS by default starting with macOS Mojave 10.14.4 beta 3. For macOS Mojave 10.14.3 and earlier, there's an optional Swift library package that can be downloaded from \"More Downloads\" for Apple Developers at https://developer.apple.com/download/more/"
+        )
     }
 
     static func productRequiresHigherPlatformVersion(
@@ -637,15 +653,15 @@ extension Basics.Diagnostic {
         productPlatform: SupportedPlatform
     ) -> Self {
         .error("""
-            the \(target.type.rawValue) '\(target.name)' requires \
-            \(targetPlatform.platform.name) \(targetPlatform.version.versionString), \
-            but depends on the product '\(product)' which requires \
-            \(productPlatform.platform.name) \(productPlatform.version.versionString); \
-            consider changing the \(target.type.rawValue) '\(target.name)' to require \
-            \(productPlatform.platform.name) \(productPlatform.version.versionString) or later, \
-            or the product '\(product)' to require \
-            \(targetPlatform.platform.name) \(targetPlatform.version.versionString) or earlier.
-            """)
+        the \(target.type.rawValue) '\(target.name)' requires \
+        \(targetPlatform.platform.name) \(targetPlatform.version.versionString), \
+        but depends on the product '\(product)' which requires \
+        \(productPlatform.platform.name) \(productPlatform.version.versionString); \
+        consider changing the \(target.type.rawValue) '\(target.name)' to require \
+        \(productPlatform.platform.name) \(productPlatform.version.versionString) or later, \
+        or the product '\(product)' to require \
+        \(targetPlatform.platform.name) \(targetPlatform.version.versionString) or earlier.
+        """)
     }
 
     static func binaryTargetsNotSupported() -> Self {
@@ -656,7 +672,7 @@ extension Basics.Diagnostic {
 extension BuildParameters {
     /// Returns a named bundle's path inside the build directory.
     func bundlePath(named name: String) -> AbsolutePath {
-        return buildPath.appending(component: name + self.triple.nsbundleExtension)
+        buildPath.appending(component: name + self.triple.nsbundleExtension)
     }
 }
 
@@ -705,20 +721,20 @@ extension ResolvedPackage {
 
 extension ResolvedProduct {
     private var isAutomaticLibrary: Bool {
-        return self.type == .library(.automatic)
+        self.type == .library(.automatic)
     }
 
     private var isBinaryOnly: Bool {
         return self.targets.filter({ !($0.underlying is BinaryTarget) }).isEmpty
     }
 
     private var isPlugin: Bool {
-        return self.type == .plugin
+        self.type == .plugin
     }
 
-    // We shouldn't create product descriptions for automatic libraries, plugins or products which consist solely of binary targets, because they don't produce any output.
+    // We shouldn't create product descriptions for automatic libraries, plugins or products which consist solely of
+    // binary targets, because they don't produce any output.
     fileprivate var shouldCreateProductDescription: Bool {
-        return !isAutomaticLibrary && !isBinaryOnly && !isPlugin
+        !self.isAutomaticLibrary && !self.isBinaryOnly && !self.isPlugin
     }
 }
-