Pass -static-stdlib for all compiler jobs

--static-swift-stdlib support on Linux is introduced by swiftlang#2921
but it doesn't work when linking CoreFoundation.

When CoreFoundation is used on a project and a user uses
--static-swift-stdlib, SwiftPM compiled object files without
-static-stdlib and linked them with that option. This mismatch of
compiler option broke swift autolink mechanism.

The object files built without -static-stdlib references
`/lib/swift/CoreFoundation/module.map`, which is intended to be
used for dynamic linking, and the modulemap doesn't have
`link "CoreFoundation"` statement. So the autolink sections in built
object files doesn't have `-lCoreFoundation` and it causes linking
failure.

This patch changes to pass `-static-stdlib` for all compiler jobs if
necessary. This enables to refenrece `/lib/swift_static/CoreFoundation/module.map`
when using `--static-swift-stdlib` and it resolves linking failures.

Author: kateinoigakukun

Sources/Build/BuildPlan.swift

@@ -642,6 +642,7 @@ public final class SwiftTargetBuildDescription {
         args += activeCompilationConditions
         args += additionalFlags
         args += moduleCacheArgs
+        args += stdlibArguments
         args += buildParameters.sanitizers.compileSwiftFlags()
         args += ["-parseable-output"]
 
@@ -763,6 +764,7 @@ public final class SwiftTargetBuildDescription {
         result += activeCompilationConditions
         result += additionalFlags
         result += moduleCacheArgs
+        result += stdlibArguments
         result += self.buildSettingsFlags()
 
         return result
@@ -811,6 +813,7 @@ public final class SwiftTargetBuildDescription {
         result += activeCompilationConditions
         result += additionalFlags
         result += moduleCacheArgs
+        result += stdlibArguments
         result += buildParameters.sanitizers.compileSwiftFlags()
         result += ["-parseable-output"]
         result += self.buildSettingsFlags()
@@ -976,6 +979,15 @@ public final class SwiftTargetBuildDescription {
     private var moduleCacheArgs: [String] {
         return ["-module-cache-path", buildParameters.moduleCache.pathString]
     }
+
+    private var stdlibArguments: [String] {
+        if buildParameters.shouldLinkStaticSwiftStdlib &&
+            buildParameters.triple.isSupportingStaticStdlib {
+            return ["-static-stdlib"]
+        } else {
+            return []
+        }
+    }
 }
 
 /// The build description for a product.
@@ -1105,7 +1117,7 @@ public final class ProductBuildDescription {
             if buildParameters.shouldLinkStaticSwiftStdlib {
                 if buildParameters.triple.isDarwin() {
                     diagnostics.emit(.swiftBackDeployError)
-                } else if buildParameters.triple.isLinux() || buildParameters.triple.arch == .wasm32 {
+                } else if buildParameters.triple.isSupportingStaticStdlib {
                     args += ["-static-stdlib"]
                 }
             }
@@ -1908,3 +1920,9 @@ fileprivate extension Triple.OS {
         }
     }
 }
+
+fileprivate extension Triple {
+    var isSupportingStaticStdlib: Bool {
+        isLinux() || arch == .wasm32
+    }
+}

Tests/BuildTests/BuildPlanTests.swift

@@ -2421,6 +2421,43 @@ final class BuildPlanTests: XCTestCase {
         ])
     }
 
+    func testShouldLinkStaticSwiftStdlib() throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Pkg/Sources/exe/main.swift",
+            "/Pkg/Sources/lib/lib.swift"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+        let graph = loadPackageGraph(fs: fs, diagnostics: diagnostics,
+            manifests: [
+                Manifest.createV4Manifest(
+                    name: "Pkg",
+                    path: "/Pkg",
+                    url: "/Pkg",
+                    packageKind: .root,
+                    targets: [
+                        TargetDescription(name: "exe", dependencies: ["lib"]),
+                        TargetDescription(name: "lib", dependencies: []),
+                    ]),
+            ]
+        )
+
+        let supportingTriples: [TSCUtility.Triple] = [.x86_64Linux, .arm64Linux, .wasi]
+        for triple in supportingTriples {
+            let result = BuildPlanResult(plan: try BuildPlan(
+                buildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true, destinationTriple: triple),
+                graph: graph, diagnostics: diagnostics, fileSystem: fs)
+            )
+
+            let exe = try result.target(for: "exe").swiftTarget().compileArguments()
+            XCTAssertTrue(exe.contains("-static-stdlib"))
+            let lib = try result.target(for: "lib").swiftTarget().compileArguments()
+            XCTAssertTrue(lib.contains("-static-stdlib"))
+            let link = try result.buildProduct(for: "exe").linkArguments()
+            XCTAssertTrue(link.contains("-static-stdlib"))
+        }
+    }
+
     func testBinaryTargets(platform: String, arch: String, destinationTriple: TSCUtility.Triple)
     throws {
         let fs = InMemoryFileSystem(emptyFiles: