Implement pkg-config flag deduplication

Should reduce a lot of the noise in Cflags and Libraries.

See #455

Author: amyspark

Cargo.toml

@@ -45,6 +45,7 @@ glob = "0.3"
 itertools = "0.14"
 implib = "0.3.5"
 object = { version = "0.36.4", default-features = false, features = ["std", "read_core", "pe"] }
+pkg-config = "0.3.32"
 
 [features]
 default = []

src/pkg_config_gen.rs

@@ -2,7 +2,10 @@
 
 use crate::build::CApiConfig;
 use crate::install::InstallPaths;
-use std::path::{Component, Path, PathBuf};
+use std::{
+    collections::HashSet,
+    path::{Component, Path, PathBuf},
+};
 
 fn canonicalize<P: AsRef<Path>>(path: P) -> String {
     let mut stack = Vec::with_capacity(16);
@@ -57,6 +60,14 @@ fn canonicalize<P: AsRef<Path>>(path: P) -> String {
     }
 }
 
+use pkg_config;
+
+#[derive(Debug, Clone)]
+struct PkgConfigDedupInformation {
+    requires: Vec<pkg_config::Library>,
+    requires_private: Vec<pkg_config::Library>,
+}
+
 #[derive(Debug, Clone)]
 pub struct PkgConfig {
     prefix: PathBuf,
@@ -77,6 +88,8 @@ pub struct PkgConfig {
     cflags: Vec<String>,
 
     conflicts: Vec<String>,
+
+    dedup: PkgConfigDedupInformation,
 }
 
 impl PkgConfig {
@@ -99,19 +112,53 @@ impl PkgConfig {
             Some(reqs) => reqs.split(',').map(|s| s.trim().to_string()).collect(),
             _ => Vec::new(),
         };
+
+        let requires_libs = {
+            let cfg = {
+                let mut c = pkg_config::Config::new();
+                // This is not sinkholed by cargo-c
+                c.env_metadata(false);
+
+                c
+            };
+
+            // TODO: log which probe fails
+            requires
+                .iter()
+                .flat_map(|req| cfg.probe(req))
+                .collect::<Vec<_>>()
+        };
+
         let requires_private = match &capi_config.pkg_config.requires_private {
             Some(reqs) => reqs.split(',').map(|s| s.trim().to_string()).collect(),
             _ => Vec::new(),
         };
 
+        let requires_private_libs = {
+            let cfg = {
+                let mut c = pkg_config::Config::new();
+                c.statik(true);
+                // This is not sinkholed by cargo-c
+                c.env_metadata(false);
+
+                c
+            };
+
+            // TODO: log which probe fails
+            requires_private
+                .iter()
+                .flat_map(|req| cfg.probe(req))
+                .collect::<Vec<_>>()
+        };
+
         let mut libdir = PathBuf::new();
         libdir.push("${libdir}");
         if let Some(subdir) = &capi_config.library.install_subdir {
             libdir.push(subdir);
         }
 
         let libs = vec![
-            format!("-L{}", libdir.display()),
+            format!("-L{}", canonicalize(libdir.display().to_string())),
             format!("-l{}", capi_config.library.name),
         ];
 
@@ -146,6 +193,11 @@ impl PkgConfig {
             cflags: vec![cflags],
 
             conflicts: Vec::new(),
+
+            dedup: PkgConfigDedupInformation {
+                requires: requires_libs,
+                requires_private: requires_private_libs,
+            },
         }
     }
 
@@ -236,7 +288,75 @@ impl PkgConfig {
         self.render_help(String::with_capacity(1024)).unwrap()
     }
 
+    fn get_libs_cflags(arg: &[pkg_config::Library]) -> (HashSet<String>, HashSet<String>) {
+        let mut libs: HashSet<String> = HashSet::new();
+        let mut cflags: HashSet<String> = HashSet::new();
+
+        for lib in arg.iter() {
+            for lib in lib.include_paths.iter() {
+                libs.insert(format!("-I{}", lib.to_string_lossy()));
+            }
+            for lib in lib.link_files.iter() {
+                libs.insert(lib.to_string_lossy().to_string());
+            }
+            for lib in lib.libs.iter() {
+                libs.insert(format!("-l{}", lib));
+            }
+            for lib in lib.link_paths.iter() {
+                libs.insert(format!("-L{}", lib.to_string_lossy()));
+            }
+            for lib in lib.frameworks.iter() {
+                libs.insert(format!("-framework {}", lib));
+            }
+            for lib in lib.framework_paths.iter() {
+                libs.insert(format!("-F{}", lib.to_string_lossy()));
+            }
+            for lib in lib.defines.iter() {
+                let v = match lib.1 {
+                    Some(v) => format!("-D{}={}", lib.0, v),
+                    None => format!("D{}", lib.0),
+                };
+                libs.insert(v);
+            }
+            for lib in lib.ld_args.iter() {
+                cflags.insert(format!("-Wl,{}", lib.join(",")));
+            }
+        }
+
+        (libs, cflags)
+    }
+
+    fn dedup_libs_cflags(
+        requires: &[pkg_config::Library],
+        flags: &[String],
+    ) -> (String, String) {
+        let (libs, cflags) = PkgConfig::get_libs_cflags(requires);
+
+        let libs = flags
+            .iter()
+            .filter(|lib| !libs.contains(lib.as_str()))
+            .map(|lib| lib.as_str())
+            .collect::<Vec<_>>()
+            .join(" ");
+        let cflags = flags
+            .iter()
+            .filter(|lib| !cflags.contains(lib.as_str()))
+            .map(|lib| lib.as_str())
+            .collect::<Vec<_>>()
+            .join(" ");
+
+        (libs, cflags)
+    }
+
     fn render_help<W: core::fmt::Write>(&self, mut w: W) -> Result<W, core::fmt::Error> {
+        // Dedup
+        // What libs are already known here?
+        let (dedup_libs, dedup_cflags) =
+            PkgConfig::dedup_libs_cflags(&self.dedup.requires, &self.libs);
+
+        let (dedup_libs_private, dedup_cflags_private) =
+            PkgConfig::dedup_libs_cflags(&self.dedup.requires_private, &self.libs_private);
+
         writeln!(w, "prefix={}", canonicalize(&self.prefix))?;
         writeln!(w, "exec_prefix={}", canonicalize(&self.exec_prefix))?;
         writeln!(w, "libdir={}", canonicalize(&self.libdir))?;
@@ -247,15 +367,15 @@ impl PkgConfig {
         writeln!(w, "Name: {}", self.name)?;
         writeln!(w, "Description: {}", self.description.replace('\n', " "))?; // avoid endlines
         writeln!(w, "Version: {}", self.version)?;
-        writeln!(w, "Libs: {}", self.libs.join(" "))?;
-        writeln!(w, "Cflags: {}", self.cflags.join(" "))?;
+        writeln!(w, "Libs: {}", dedup_libs)?;
+        writeln!(w, "Cflags: {}", dedup_cflags)?;
 
         if !self.libs_private.is_empty() {
-            writeln!(w, "Libs.private: {}", self.libs_private.join(" "))?;
+            writeln!(w, "Libs.private: {}", dedup_libs_private)?;
         }
 
         if !self.requires.is_empty() {
-            writeln!(w, "Requires: {}", self.requires.join(", "))?;
+            writeln!(w, "Requires: {}", dedup_cflags_private)?;
         }
 
         if !self.requires_private.is_empty() {