automatically populate linker flags for dynamic library dependencies

Author: tayloraswift

Sources/Build/BuildPlan/BuildPlan+Product.swift

@@ -44,15 +44,27 @@ extension BuildPlan {
         }
 
         // Add flags for binary dependencies.
-        for binaryPath in dependencies.libraryBinaryPaths {
+        var dynamicLibraries: Set<Substring> = []
+        for binaryPath in dependencies.sharedLibraryBinaries {
+            if binaryPath.basename.starts(with: "lib"), binaryPath.extension == "so" {
+                buildProduct.additionalFlags += ["-L", binaryPath.parentDirectory.pathString]
+                dynamicLibraries.insert(binaryPath.basenameWithoutExt.dropFirst(3))
+            } else {
+                self.observabilityScope.emit(error: "unexpected binary library")
+            }
+        }
+        for binaryPath in dependencies.xcframeworkBinaries {
             if binaryPath.extension == "framework" {
                 buildProduct.additionalFlags += ["-framework", binaryPath.basenameWithoutExt]
             } else if binaryPath.basename.starts(with: "lib") {
-                buildProduct.additionalFlags += ["-l\(binaryPath.basenameWithoutExt.dropFirst(3))"]
+                dynamicLibraries.insert(binaryPath.basenameWithoutExt.dropFirst(3))
             } else {
                 self.observabilityScope.emit(error: "unexpected binary framework")
             }
         }
+        for dynamicLibrary: Substring in dynamicLibraries {
+            buildProduct.additionalFlags += ["-l\(dynamicLibrary)"]
+        }
 
         // Don't link libc++ or libstd++ when building for Embedded Swift.
         // Users can still link it manually for embedded platforms when needed,
@@ -102,7 +114,7 @@ extension BuildPlan {
         buildProduct.staticTargets = dependencies.staticTargets.map(\.module)
         buildProduct.dylibs = dependencies.dylibs
         buildProduct.objects += try dependencies.staticTargets.flatMap { try $0.objects }
-        buildProduct.libraryBinaryPaths = dependencies.libraryBinaryPaths
+        buildProduct.libraryBinaryPaths = dependencies.xcframeworkBinaries
         buildProduct.availableTools = dependencies.availableTools
     }
 
@@ -113,7 +125,8 @@ extension BuildPlan {
         dylibs: [ProductBuildDescription],
         staticTargets: [ModuleBuildDescription],
         systemModules: [ResolvedModule],
-        libraryBinaryPaths: Set<AbsolutePath>,
+        sharedLibraryBinaries: Set<AbsolutePath>,
+        xcframeworkBinaries: Set<AbsolutePath>,
         availableTools: [String: AbsolutePath]
     ) {
         let product = productDescription.product
@@ -230,7 +243,8 @@ extension BuildPlan {
         var linkLibraries = [ProductBuildDescription]()
         var staticTargets = [ModuleBuildDescription]()
         var systemModules = [ResolvedModule]()
-        var libraryBinaryPaths: Set<AbsolutePath> = []
+        var sharedLibraryBinaries: Set<AbsolutePath> = []
+        var xcframeworkBinaries: Set<AbsolutePath> = []
         var availableTools = [String: AbsolutePath]()
 
         for dependency in allDependencies {
@@ -294,11 +308,17 @@ extension BuildPlan {
                             triple: productDescription.buildParameters.triple
                         )
                         for library in libraries {
-                            libraryBinaryPaths.insert(library.libraryPath)
+                            xcframeworkBinaries.insert(library.libraryPath)
                         }
                     case .artifactsArchive:
-                        let tools = try self.parseArtifactsArchive(
-                            for: binaryTarget, triple: productDescription.buildParameters.triple
+                        let libraries = try self.parseLibraries(
+                            in: binaryTarget, triple: productDescription.buildParameters.triple
+                        )
+                        for library in libraries {
+                            sharedLibraryBinaries.insert(library.libraryPath)
+                        }
+                        let tools = try self.parseExecutables(
+                            in: binaryTarget, triple: productDescription.buildParameters.triple
                         )
                         tools.forEach { availableTools[$0.name] = $0.executablePath }
                     case .unknown:
@@ -326,14 +346,6 @@ extension BuildPlan {
             })
         }
 
-        return (linkLibraries, staticTargets, systemModules, libraryBinaryPaths, availableTools)
-    }
-
-    /// Extracts the artifacts  from an artifactsArchive
-    private func parseArtifactsArchive(for binaryTarget: BinaryModule, triple: Triple) throws -> [ExecutableInfo] {
-        try self.externalExecutablesCache.memoize(key: binaryTarget) {
-            let execInfos = try binaryTarget.parseArtifactArchives(for: triple, fileSystem: self.fileSystem)
-            return execInfos.filter { !$0.supportedTriples.isEmpty }
-        }
+        return (linkLibraries, staticTargets, systemModules, sharedLibraryBinaries, xcframeworkBinaries, availableTools)
     }
 }

Sources/Build/BuildPlan/BuildPlan+Swift.swift

@@ -41,7 +41,7 @@ extension BuildPlan {
             case let target as BinaryModule:
                 switch target.kind {
                 case .artifactsArchive:
-                    let libraries = try self.parseArtifactbundle(for: target, triple: swiftTarget.buildParameters.triple)
+                    let libraries = try self.parseLibraries(in: target, triple: swiftTarget.buildParameters.triple)
                     for library in libraries {
                         library.headersPaths.forEach {
                             swiftTarget.additionalFlags += ["-I", $0.pathString]

Sources/Build/BuildPlan/BuildPlan.swift

@@ -680,13 +680,20 @@ public class BuildPlan: SPMBuildCore.BuildPlan {
         return result
     }
 
-    /// Extracts the library information from an Artifact Bundle.
-    func parseArtifactbundle(for binaryTarget: BinaryModule, triple: Basics.Triple) throws -> [LibraryInfo] {
+    /// Extracts the information about executables in an Artifact Bundle, with caching.
+    func parseExecutables(in binaryTarget: BinaryModule, triple: Basics.Triple) throws -> [ExecutableInfo] {
+        try self.externalExecutablesCache.memoize(key: binaryTarget) {
+            let execInfos = try binaryTarget.parseExecutables(for: triple, fileSystem: self.fileSystem)
+            return execInfos.filter { !$0.supportedTriples.isEmpty }
+        }
+    }
+    /// Extracts the information about libraries in an Artifact Bundle, with caching.
+    func parseLibraries(in binaryTarget: BinaryModule, triple: Basics.Triple) throws -> [LibraryInfo] {
         try self.externalLibrariesCache.memoize(key: binaryTarget) {
-            try binaryTarget.parseLibraryArtifacts(for: triple, fileSystem: self.fileSystem)
+            try binaryTarget.parseLibraries(for: triple, fileSystem: self.fileSystem)
         }
     }
-    /// Extracts the library information from an XCFramework.
+    /// Extracts the library information from an XCFramework, with caching.
     func parseXCFramework(for binaryTarget: BinaryModule, triple: Basics.Triple) throws -> [LibraryInfo] {
         try self.externalLibrariesCache.memoize(key: binaryTarget) {
             try binaryTarget.parseXCFrameworks(for: triple, fileSystem: self.fileSystem)

Sources/SPMBuildCore/BinaryTarget+Extensions.swift

@@ -55,8 +55,7 @@ extension BinaryModule {
             .map { [try AbsolutePath(validating: $0, relativeTo: libraryDir)] } ?? [] + [libraryDir]
         return [LibraryInfo(libraryPath: libraryFile, headersPaths: headersDirs)]
     }
-
-    public func parseLibraryArtifacts(for triple: Triple, fileSystem: FileSystem) throws -> [LibraryInfo] {
+    public func parseLibraries(for triple: Triple, fileSystem: FileSystem) throws -> [LibraryInfo] {
         let metadata = try ArtifactsArchiveMetadata.parse(fileSystem: fileSystem, rootPath: self.artifactPath)
         return metadata.artifacts.reduce(into: []) {
             guard case .library = $1.value.type else {
@@ -68,9 +67,8 @@ extension BinaryModule {
 
             $0.append(.init(libraryPath: libraryFile, headersPaths: [libraryDir]))
         }
-
     }
-    public func parseArtifactArchives(for triple: Triple, fileSystem: FileSystem) throws -> [ExecutableInfo] {
+    public func parseExecutables(for triple: Triple, fileSystem: FileSystem) throws -> [ExecutableInfo] {
         // The host triple might contain a version which we don't want to take into account here.
         let versionLessTriple = try triple.withoutVersion()
         // We return at most a single variant of each artifact.
@@ -96,6 +94,11 @@ extension BinaryModule {
             }
         }
     }
+
+    @available(*, deprecated, renamed: "parseExecutables(for:fileSystem:)")
+    public func parseArtifactArchives(for triple: Triple, fileSystem: FileSystem) throws -> [ExecutableInfo] {
+        try self.parseExecutables(for: triple, fileSystem: fileSystem)
+    }
 }
 
 extension Triple {

Sources/SPMBuildCore/Plugins/PluginInvocation.swift

@@ -621,7 +621,7 @@ fileprivate func collectAccessibleTools(
         // For a binary target we create a `vendedTool`.
         if let module = executableOrBinaryModule as? BinaryModule {
             // TODO: Memoize this result for the host triple
-            let execInfos = try module.parseArtifactArchives(for: hostTriple, fileSystem: fileSystem)
+            let execInfos = try module.parseExecutables(for: hostTriple, fileSystem: fileSystem)
             return try execInfos.map{ .vendedTool(name: $0.name, path: $0.executablePath, supportedTriples: try $0.supportedTriples.map{ try $0.withoutVersion().tripleString }) }
         }
         // For an executable target we create a `builtTool`.