[PackageModel] Toolchain: Split SwiftTesting flags between swift comp… (#7903)

…iler and linker

### Motivation:

Keeping them together broke Symbol Graph Extract tool because it cannot
handle `-Xlinker` flags.

### Modifications:

- Adjust `deriveMacOSSpecificSwiftTestingFlags` to produce two arrays -
one for swift compiler and one for linker flags.

### Result:

`extraFlags.swiftCompilerFlags` no longer includes `-Xlinker` flags.

Author: xedin

Sources/PackageModel/UserToolchain.swift

@@ -410,23 +410,23 @@ public final class UserToolchain: Toolchain {
     static func deriveMacOSSpecificSwiftTestingFlags(
         derivedSwiftCompiler: AbsolutePath,
         fileSystem: any FileSystem
-    ) -> [String] {
+    ) -> (swiftCFlags: [String], linkerFlags: [String]) {
         // If this is CommandLineTools all we need to add is a frameworks path.
         if let frameworksPath = try? AbsolutePath(
             validating: "../../Library/Developer/Frameworks",
             relativeTo: resolveSymlinks(derivedSwiftCompiler).parentDirectory
         ), fileSystem.exists(frameworksPath.appending("Testing.framework")) {
-            return [
-                "-F", frameworksPath.pathString,
-                "-Xlinker", "-rpath",
-                "-Xlinker", frameworksPath.pathString
-            ]
+            return (swiftCFlags: [
+                "-F", frameworksPath.pathString
+            ], linkerFlags: [
+                "-rpath", frameworksPath.pathString
+            ])
         }
 
         guard let toolchainLibDir = try? toolchainLibDir(
             swiftCompilerPath: derivedSwiftCompiler
         ) else {
-            return []
+            return (swiftCFlags: [], linkerFlags: [])
         }
 
         let testingLibDir = toolchainLibDir.appending(
@@ -438,15 +438,16 @@ public final class UserToolchain: Toolchain {
         )
 
         guard fileSystem.exists(testingLibDir), fileSystem.exists(testingPluginsDir) else {
-            return []
+            return (swiftCFlags: [], linkerFlags: [])
         }
 
-        return [
+        return (swiftCFlags: [
             "-I", testingLibDir.pathString,
             "-L", testingLibDir.pathString,
-            "-plugin-path", testingPluginsDir.pathString,
-            "-Xlinker", "-rpath", "-Xlinker", testingLibDir.pathString,
-        ]
+            "-plugin-path", testingPluginsDir.pathString
+        ], linkerFlags: [
+            "-rpath", testingLibDir.pathString
+        ])
     }
 
     internal static func deriveSwiftCFlags(
@@ -669,11 +670,15 @@ public final class UserToolchain: Toolchain {
         self.targetTriple = triple
 
         var swiftCompilerFlags: [String] = []
+        var extraLinkerFlags: [String] = []
+
         #if os(macOS)
-        swiftCompilerFlags += Self.deriveMacOSSpecificSwiftTestingFlags(
+        let (swiftCFlags, linkerFlags) = Self.deriveMacOSSpecificSwiftTestingFlags(
             derivedSwiftCompiler: swiftCompilers.compile,
             fileSystem: fileSystem
         )
+        swiftCompilerFlags += swiftCFlags
+        extraLinkerFlags += linkerFlags
         #endif
 
         swiftCompilerFlags += try Self.deriveSwiftCFlags(
@@ -683,11 +688,13 @@ public final class UserToolchain: Toolchain {
             fileSystem: fileSystem
         )
 
+        extraLinkerFlags += swiftSDK.toolset.knownTools[.linker]?.extraCLIOptions ?? []
+
         self.extraFlags = BuildFlags(
             cCompilerFlags: swiftSDK.toolset.knownTools[.cCompiler]?.extraCLIOptions ?? [],
             cxxCompilerFlags: swiftSDK.toolset.knownTools[.cxxCompiler]?.extraCLIOptions ?? [],
             swiftCompilerFlags: swiftCompilerFlags,
-            linkerFlags: swiftSDK.toolset.knownTools[.linker]?.extraCLIOptions ?? [],
+            linkerFlags: extraLinkerFlags,
             xcbuildFlags: swiftSDK.toolset.knownTools[.xcbuild]?.extraCLIOptions ?? [])
 
         self.includeSearchPaths = swiftSDK.pathsConfiguration.includeSearchPaths ?? []

Tests/BuildTests/BuildPlanTests.swift

@@ -4649,6 +4649,119 @@ final class BuildPlanTests: XCTestCase {
         ])
     }
 
+    func testSwiftTestingFlagsOnMacOSWithCustomToolchain() async throws {
+        #if !os(macOS)
+        // This is testing swift-testing in a toolchain which is macOS only feature.
+        try XCTSkipIf(true, "test is only supported on macOS")
+        #endif
+
+        let fs = InMemoryFileSystem(
+            emptyFiles:
+            "/fake/path/lib/swift/macosx/testing/Testing.swiftmodule",
+            "/fake/path/lib/swift/host/plugins/testing/libTesting.dylib",
+            "/Pkg/Sources/Lib/main.swift",
+            "/Pkg/Tests/LibTest/test.swift"
+        )
+        try fs.createMockToolchain()
+
+        let userSwiftSDK = SwiftSDK(
+            hostTriple: .x86_64MacOS,
+            targetTriple: .x86_64MacOS,
+            toolset: .init(
+                knownTools: [
+                    .cCompiler: .init(extraCLIOptions: []),
+                    .swiftCompiler: .init(extraCLIOptions: []),
+                ],
+                rootPaths: ["/fake/path/to"]
+            ),
+            pathsConfiguration: .init(
+                sdkRootPath: "/fake/sdk",
+                swiftResourcesPath: "/fake/lib/swift",
+                swiftStaticResourcesPath: "/fake/lib/swift_static"
+            )
+        )
+        let mockToolchain = try UserToolchain(
+            swiftSDK: userSwiftSDK,
+            environment: .mockEnvironment,
+            fileSystem: fs
+        )
+
+        XCTAssertEqual(
+            mockToolchain.extraFlags.swiftCompilerFlags,
+            [
+                "-I", "/fake/path/lib/swift/macosx/testing",
+                "-L", "/fake/path/lib/swift/macosx/testing",
+                "-plugin-path", "/fake/path/lib/swift/host/plugins/testing",
+                "-sdk", "/fake/sdk",
+            ]
+        )
+        XCTAssertEqual(
+            mockToolchain.extraFlags.linkerFlags,
+            ["-rpath", "/fake/path/lib/swift/macosx/testing"]
+        )
+
+        let observability = ObservabilitySystem.makeForTesting()
+        let graph = try loadModulesGraph(
+            fileSystem: fs,
+            manifests: [
+                Manifest.createRootManifest(
+                    displayName: "Pkg",
+                    path: "/Pkg",
+                    targets: [
+                        TargetDescription(name: "Lib", dependencies: []),
+                        TargetDescription(
+                            name: "LibTest",
+                            dependencies: ["Lib"],
+                            type: .test
+                        ),
+                    ]
+                ),
+            ],
+            observabilityScope: observability.topScope
+        )
+        XCTAssertNoDiagnostics(observability.diagnostics)
+
+        let result = try await BuildPlanResult(plan: mockBuildPlan(
+            toolchain: mockToolchain,
+            graph: graph,
+            commonFlags: .init(),
+            fileSystem: fs,
+            observabilityScope: observability.topScope
+        ))
+        result.checkProductsCount(2)
+        result.checkTargetsCount(3)
+
+        let testProductLinkArgs = try result.buildProduct(for: "Lib").linkArguments()
+        XCTAssertMatch(testProductLinkArgs, [
+            .anySequence,
+            "-I", "/fake/path/lib/swift/macosx/testing",
+            "-L", "/fake/path/lib/swift/macosx/testing",
+            .anySequence,
+            "-Xlinker", "-rpath",
+            "-Xlinker", "/fake/path/lib/swift/macosx/testing",
+        ])
+
+        let libModuleArgs = try result.moduleBuildDescription(for: "Lib").swift().compileArguments()
+        XCTAssertMatch(libModuleArgs, [
+            .anySequence,
+            "-I", "/fake/path/lib/swift/macosx/testing",
+            "-L", "/fake/path/lib/swift/macosx/testing",
+            "-plugin-path", "/fake/path/lib/swift/host/plugins/testing",
+            .anySequence,
+        ])
+        XCTAssertNoMatch(libModuleArgs, ["-Xlinker"])
+
+        let testModuleArgs = try result.moduleBuildDescription(for: "LibTest").swift().compileArguments()
+        XCTAssertMatch(testModuleArgs, [
+            .anySequence,
+            "-I", "/fake/path/lib/swift/macosx/testing",
+            "-L", "/fake/path/lib/swift/macosx/testing",
+            "-plugin-path", "/fake/path/lib/swift/host/plugins/testing",
+            .anySequence,
+        ])
+        XCTAssertNoMatch(testModuleArgs, ["-Xlinker"])
+    }
+
     func testUserToolchainWithToolsetCompileFlags() async throws {
         let fileSystem = InMemoryFileSystem(
             emptyFiles: