Derive dynamic libraries explicitly to avoid linker errors for "release" builds (#7284)

Derive dynamic libraries explicitly to avoid linker errors for "release"
builds. rdar://108561857

### Motivation:

One of the test fixtures in XPM that we've been using since 2019
succeeds in Debug builds but fails in Release builds with linker errors.
The fix is to derive dynamic libraries for linking.

### Modifications:

Derive dynamic libraries explicitly for linking.

### Result:

Now release builds are also successful.

Author: pusukuri

Sources/Build/BuildPlan/BuildPlan+Product.swift

@@ -143,6 +143,12 @@ extension BuildPlan {
             topLevelDependencies = []
         }
 
+        // get the dynamic libraries for explicitly linking rdar://108561857
+        func recursiveDynamicLibraries(for product: ResolvedProduct) throws -> [ResolvedProduct] {
+            let dylibs = try computeDependencies(of: product, buildParameters: buildParameters).dylibs
+            return try dylibs + dylibs.flatMap { try recursiveDynamicLibraries(for: $0) }
+        }
+
         // Sort the product targets in topological order.
         let nodes: [ResolvedTarget.Dependency] = product.targets.map { .target($0, conditions: []) }
         let allTargets = try topologicalSort(nodes, successors: { dependency in
@@ -175,7 +181,9 @@ extension BuildPlan {
                     return productDependencies
                 case .plugin:
                     return shouldExcludePlugins ? [] : productDependencies
-                case .library(.dynamic), .test, .executable, .snippet, .macro:
+                case .library(.dynamic):
+                    return try recursiveDynamicLibraries(for: product).map { .product($0, conditions: []) }
+                case .test, .executable, .snippet, .macro:
                     return []
                 }
             }

Tests/BuildTests/BuildPlanTests.swift

@@ -6198,4 +6198,76 @@ final class BuildPlanTests: XCTestCase {
         XCTAssertEqual(try result.buildProduct(for: "exe").linkArguments(), linkArguments)
         XCTAssertNoDiagnostics(observability.diagnostics)
     }
+
+    // testing of deriving dynamic libraries for explicitly linking rdar://108561857
+    func testDerivingDylibs() throws {
+        let fs = InMemoryFileSystem(
+            emptyFiles:
+            "/thisPkg/Sources/exe/main.swift",
+            "/fooPkg/Sources/FooLogging/file.swift",
+            "/barPkg/Sources/BarLogging/file.swift"
+        )
+        let observability = ObservabilitySystem.makeForTesting()
+        let graph = try loadPackageGraph(
+            fileSystem: fs,
+            manifests: [
+                Manifest.createFileSystemManifest(
+                    displayName: "fooPkg",
+                    path: "/fooPkg",
+                    dependencies: [
+                        .localSourceControl(path: "/barPkg", requirement: .upToNextMajor(from: "1.0.0")),
+                    ],
+                    products: [
+                        ProductDescription(name: "FooLogging", type: .library(.dynamic), targets: ["FooLogging"]),
+                    ],
+                    targets: [
+                        TargetDescription(
+                            name: "FooLogging",
+                            dependencies: [.product(name: "BarLogging", package: "barPkg")]
+                        ),
+                    ]
+                ),
+                Manifest.createFileSystemManifest(
+                    displayName: "barPkg",
+                    path: "/barPkg",
+                    products: [
+                        ProductDescription(name: "BarLogging", type: .library(.dynamic), targets: ["BarLogging"]),
+                    ],
+                    targets: [
+                        TargetDescription(name: "BarLogging", dependencies: []),
+                    ]
+                ),
+                Manifest.createRootManifest(
+                    displayName: "thisPkg",
+                    path: "/thisPkg",
+                    toolsVersion: .v5_8,
+                    dependencies: [
+                        .localSourceControl(path: "/fooPkg", requirement: .upToNextMajor(from: "1.0.0")),
+                    ],
+                    targets: [
+                        TargetDescription(
+                            name: "exe",
+                            dependencies: [.product(name: "FooLogging", package: "fooPkg"),],
+                            type: .executable
+                        ),
+                    ]
+                ),
+            ],
+            observabilityScope: observability.topScope
+        )
+        XCTAssertNoDiagnostics(observability.diagnostics)
+        let result = try BuildPlanResult(plan: BuildPlan(
+            buildParameters: mockBuildParameters(shouldLinkStaticSwiftStdlib: true),
+            graph: graph,
+            fileSystem: fs,
+            observabilityScope: observability.topScope
+        ))
+        result.checkProductsCount(3)
+        result.checkTargetsCount(3)
+        XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "FooLogging" })
+        XCTAssertTrue(result.targetMap.values.contains { $0.target.name == "BarLogging" })
+        let buildProduct = try XCTUnwrap(result.productMap["exe"])
+        let dylibs = Array(buildProduct.dylibs.map({$0.product.name})).sorted()
+        XCTAssertEqual(dylibs, ["BarLogging", "FooLogging"])
+    }
 }