Swift SDKs: implement swiftResourcesPath (#6717)

Implements `swiftResourcesPath` and `swiftStaticResourcesPath` from the `swift-sdk.json` spec.

### Motivation:

SwiftPM previously knew how to parse these fields from the SDK manifest, but didn't actually do anything with them.

### Modifications:

- Pass `-resource-dir` to swiftc for compile jobs
- Pass `-resource-dir` to both swiftc and clang for link jobs

### Result:

Toolchains that override `swiftResourcesPath` and/or `swiftStaticResourcesPath` should now behave as expected.

Author: kabiroberai

Sources/Build/BuildDescription/ProductBuildDescription.swift

@@ -187,6 +187,7 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
             derivedProductType = self.product.type
         }
 
+        var isLinkingStaticStdlib = false
         switch derivedProductType {
         case .macro:
             throw InternalError("macro not supported") // should never be reached
@@ -213,11 +214,13 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
             args += self.deadStripArguments
         case .executable, .snippet:
             // Link the Swift stdlib statically, if requested.
+            // TODO: unify this logic with SwiftTargetBuildDescription.stdlibArguments
             if self.buildParameters.shouldLinkStaticSwiftStdlib {
                 if self.buildParameters.targetTriple.isDarwin() {
                     self.observabilityScope.emit(.swiftBackDeployError)
                 } else if self.buildParameters.targetTriple.isSupportingStaticStdlib {
                     args += ["-static-stdlib"]
+                    isLinkingStaticStdlib = true
                 }
             }
             args += ["-emit-executable"]
@@ -243,6 +246,16 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
             throw InternalError("unexpectedly asked to generate linker arguments for a plugin product")
         }
 
+        if let resourcesPath = self.buildParameters.toolchain.swiftResourcesPath(isStatic: isLinkingStaticStdlib) {
+            args += ["-resource-dir", "\(resourcesPath)"]
+        }
+
+        // clang resources are always in lib/swift/
+        if let dynamicResourcesPath = self.buildParameters.toolchain.swiftResourcesPath {
+            let clangResourcesPath = dynamicResourcesPath.appending("clang")
+            args += ["-Xclang-linker", "-resource-dir", "-Xclang-linker", "\(clangResourcesPath)"]
+        }
+
         // Set rpath such that dynamic libraries are looked up
         // adjacent to the product.
         if self.buildParameters.targetTriple.isLinux() {

Sources/Build/BuildDescription/SwiftTargetBuildDescription.swift

@@ -1283,12 +1283,18 @@ public final class SwiftTargetBuildDescription {
     }
 
     private var stdlibArguments: [String] {
-        if self.buildParameters.shouldLinkStaticSwiftStdlib,
-           self.buildParameters.targetTriple.isSupportingStaticStdlib
-        {
-            return ["-static-stdlib"]
-        } else {
-            return []
+        var arguments: [String] = []
+
+        let isLinkingStaticStdlib = self.buildParameters.shouldLinkStaticSwiftStdlib
+            && self.buildParameters.targetTriple.isSupportingStaticStdlib
+        if isLinkingStaticStdlib {
+            arguments += ["-static-stdlib"]
         }
+
+        if let resourcesPath = self.buildParameters.toolchain.swiftResourcesPath(isStatic: isLinkingStaticStdlib) {
+            arguments += ["-resource-dir", "\(resourcesPath)"]
+        }
+
+        return arguments
     }
 }

Sources/PackageModel/Toolchain.swift

@@ -19,6 +19,12 @@ public protocol Toolchain {
     /// Path of the `swiftc` compiler.
     var swiftCompilerPath: AbsolutePath { get }
 
+    /// Path to `lib/swift`
+    var swiftResourcesPath: AbsolutePath? { get }
+
+    /// Path to `lib/swift_static`
+    var swiftStaticResourcesPath: AbsolutePath? { get }
+
     /// Whether the used compiler is from a open source development toolchain.
     var isSwiftDevelopmentToolchain: Bool { get }
 
@@ -81,7 +87,15 @@ extension Toolchain {
             return try AbsolutePath(validating: "../../lib", relativeTo: resolveSymlinks(swiftCompilerPath))
         }
     }
-    
+
+    /// Returns the appropriate Swift resources directory path.
+    ///
+    /// - Parameter static: Controls whether to use the static or dynamic
+    /// resources directory.
+    public func swiftResourcesPath(isStatic: Bool) -> AbsolutePath? {
+        isStatic ? swiftStaticResourcesPath : swiftResourcesPath
+    }
+
     public var extraCCFlags: [String] {
         extraFlags.cCompilerFlags
     }

Sources/PackageModel/UserToolchain.swift

@@ -40,6 +40,16 @@ public final class UserToolchain: Toolchain {
     /// An array of paths to search for libraries at link time.
     public let librarySearchPaths: [AbsolutePath]
 
+    /// Path containing Swift resources for dynamic linking.
+    public var swiftResourcesPath: AbsolutePath? {
+        destination.pathsConfiguration.swiftResourcesPath
+    }
+
+    /// Path containing Swift resources for static linking.
+    public var swiftStaticResourcesPath: AbsolutePath? {
+        destination.pathsConfiguration.swiftStaticResourcesPath
+    }
+
     /// Additional flags to be passed to the build tools.
     public var extraFlags: BuildFlags
 

Tests/BuildTests/BuildPlanTests.swift

@@ -3569,6 +3569,9 @@ final class BuildPlanTests: XCTestCase {
                 Manifest.createRootManifest(
                     displayName: "Pkg",
                     path: "/Pkg",
+                    products: [
+                        ProductDescription(name: "exe", type: .executable, targets: ["exe"]),
+                    ],
                     targets: [
                         TargetDescription(name: "exe", dependencies: ["lib"]),
                         TargetDescription(name: "lib", dependencies: []),
@@ -3586,7 +3589,11 @@ final class BuildPlanTests: XCTestCase {
                 ],
                 rootPaths: try UserToolchain.default.swiftSDK.toolset.rootPaths
             ),
-            pathsConfiguration: .init(sdkRootPath: "/fake/sdk")
+            pathsConfiguration: .init(
+                sdkRootPath: "/fake/sdk",
+                swiftResourcesPath: "/fake/lib/swift",
+                swiftStaticResourcesPath: "/fake/lib/swift_static"
+            )
         )
         let mockToolchain = try UserToolchain(swiftSDK: userSwiftSDK)
         let extraBuildParameters = mockBuildParameters(toolchain: mockToolchain,
@@ -3615,6 +3622,7 @@ final class BuildPlanTests: XCTestCase {
         let exe = try result.target(for: "exe").swiftTarget().compileArguments()
         XCTAssertMatch(exe, [
             "-module-cache-path", "\(buildPath.appending(components: "ModuleCache"))",
+            "-resource-dir", "/fake/lib/swift",
             .anySequence,
             "-swift-flag-from-json",
             .anySequence,
@@ -3624,6 +3632,29 @@ final class BuildPlanTests: XCTestCase {
             .anySequence,
             "-Xcc", "-clang-command-line-flag"
         ])
+
+        let exeProduct = try result.buildProduct(for: "exe").linkArguments()
+        XCTAssertMatch(exeProduct, [.anySequence, "-resource-dir", "/fake/lib/swift", "-Xclang-linker", "-resource-dir", "-Xclang-linker", "/fake/lib/swift/clang", .anySequence])
+
+        let staticBuildParameters = {
+            var copy = extraBuildParameters
+            copy.shouldLinkStaticSwiftStdlib = true
+            // pick a triple with support for static linking
+            copy.targetTriple = .x86_64Linux
+            return copy
+        }()
+        let staticResult = try BuildPlanResult(plan: BuildPlan(
+            buildParameters: staticBuildParameters,
+            graph: graph,
+            fileSystem: fs,
+            observabilityScope: observability.topScope
+        ))
+
+        let staticExe = try staticResult.target(for: "exe").swiftTarget().compileArguments()
+        XCTAssertMatch(staticExe, [.anySequence, "-resource-dir", "/fake/lib/swift_static", .anySequence])
+
+        let staticExeProduct = try staticResult.buildProduct(for: "exe").linkArguments()
+        XCTAssertMatch(staticExeProduct, [.anySequence, "-resource-dir", "/fake/lib/swift_static", "-Xclang-linker", "-resource-dir", "-Xclang-linker", "/fake/lib/swift/clang", .anySequence])
     }
 
     func testUserToolchainWithToolsetCompileFlags() throws {

Tests/BuildTests/MockBuildTestHelper.swift

@@ -28,6 +28,8 @@ struct MockToolchain: PackageModel.Toolchain {
     let swiftCompilerPath = AbsolutePath("/fake/path/to/swiftc")
     let includeSearchPaths = [AbsolutePath]()
     let librarySearchPaths = [AbsolutePath]()
+    let swiftResourcesPath: AbsolutePath? = nil
+    let swiftStaticResourcesPath: AbsolutePath? = nil
     let isSwiftDevelopmentToolchain = false
     let swiftPluginServerPath: AbsolutePath? = nil
     let extraFlags = PackageModel.BuildFlags()