Wire in the heuristics

Author: lu-zero

Cargo.toml

@@ -32,7 +32,7 @@ cargo = "0.79.0"
 cargo-util = "0.2"
 semver = "1.0.3"
 log = "0.4"
-clap = { version="4.0.29", features=["color", "derive", "cargo"] }
+clap = { version = "4.0.29", features = ["color", "derive", "cargo", "string"] }
 regex = "1.5.6"
 cbindgen = { version="0.26.0", default-features=false }
 toml = "0.8"

src/build.rs

@@ -928,7 +928,7 @@ fn compile_with_exec(
         let pkg = &unit.pkg;
         let capi_config = load_manifest_capi_config(pkg, rustc_target)?;
         let name = &capi_config.library.name;
-        let install_paths = InstallPaths::new(name, args, &capi_config);
+        let install_paths = InstallPaths::new(name, rustc_target, args, &capi_config);
         let pkg_rustflags = &capi_config.library.rustflags;
 
         let mut leaf_args: Vec<String> = rustc_target
@@ -1018,7 +1018,7 @@ impl CPackage {
 
         let name = &capi_config.library.name;
 
-        let install_paths = InstallPaths::new(name, args, &capi_config);
+        let install_paths = InstallPaths::new(name, rustc_target, args, &capi_config);
         let build_targets = BuildTargets::new(
             name,
             rustc_target,
@@ -1057,7 +1057,7 @@ pub fn cbuild(
         }
     };
 
-    let rustc_target = target::Target::new(&target, is_target_overridden)?;
+    let rustc_target = target::Target::new(Some(&target), is_target_overridden)?;
 
     let default_kind = || match (rustc_target.os.as_str(), rustc_target.env.as_str()) {
         ("none", _) | (_, "musl") => vec!["staticlib"],

src/cli.rs

@@ -9,6 +9,8 @@ use cargo_util::{ProcessBuilder, ProcessError};
 
 use clap::{Arg, ArgAction, ArgMatches, Command, CommandFactory, Parser};
 
+use crate::target::Target;
+
 // TODO: convert to a function using cargo opt()
 #[allow(dead_code)]
 #[derive(Clone, Debug, Parser)]
@@ -56,7 +58,8 @@ struct Common {
 }
 
 fn base_cli() -> Command {
-    Common::command()
+    let default_target = Target::new::<&str>(None, false);
+    let app = Common::command()
         .allow_external_subcommands(true)
         .arg(flag("version", "Print version info and exit").short('V'))
         .arg(flag("list", "List installed commands"))
@@ -107,7 +110,24 @@ fn base_cli() -> Command {
         .arg_target_dir()
         .arg_manifest_path()
         .arg_message_format()
-        .arg_build_plan()
+        .arg_build_plan();
+
+    if let Ok(t) = default_target {
+        app.mut_arg("prefix", |a| {
+            a.default_value(t.default_prefix().as_os_str().to_os_string())
+        })
+        .mut_arg("libdir", |a| {
+            a.default_value(t.default_libdir().as_os_str().to_os_string())
+        })
+        .mut_arg("datadir", |a| {
+            a.default_value(t.default_datadir().as_os_str().to_os_string())
+        })
+        .mut_arg("includedir", |a| {
+            a.default_value(t.default_includedir().as_os_str().to_os_string())
+        })
+    } else {
+        app
+    }
 }
 
 pub fn subcommand_build(name: &'static str, about: &'static str) -> Command {

src/install.rs

@@ -6,6 +6,7 @@ use cargo_util::paths::{copy, create_dir_all};
 
 use crate::build::*;
 use crate::build_targets::BuildTargets;
+use crate::target::Target;
 
 fn append_to_destdir(destdir: Option<&Path>, path: &Path) -> PathBuf {
     if let Some(destdir) = destdir {
@@ -294,16 +295,35 @@ pub struct InstallPaths {
     pub pkgconfigdir: PathBuf,
 }
 
+fn get_path_or(args: &ArgMatches, id: &str, f: impl FnOnce() -> PathBuf) -> PathBuf {
+    if matches!(
+        args.value_source(id),
+        Some(clap::parser::ValueSource::DefaultValue)
+    ) {
+        f()
+    } else {
+        args.get_one::<PathBuf>(id).unwrap().to_owned()
+    }
+}
+
 impl InstallPaths {
-    pub fn new(_name: &str, args: &ArgMatches, capi_config: &CApiConfig) -> Self {
+    pub fn new(
+        _name: &str,
+        rustc_target: &Target,
+        args: &ArgMatches,
+        capi_config: &CApiConfig,
+    ) -> Self {
         let destdir = args.get_one::<PathBuf>("destdir").map(PathBuf::from);
-        let prefix = args
-            .get_one::<PathBuf>("prefix")
-            .map(PathBuf::from)
-            .unwrap_or_else(|| "/usr/local".into());
-        let libdir = prefix.join(args.get_one::<PathBuf>("libdir").unwrap());
-        let includedir = prefix.join(args.get_one::<PathBuf>("includedir").unwrap());
-        let datarootdir = prefix.join(args.get_one::<PathBuf>("datarootdir").unwrap());
+        let prefix = get_path_or(args, "prefix", || rustc_target.default_prefix());
+        let libdir = prefix.join(get_path_or(args, "libdir", || {
+            rustc_target.default_libdir()
+        }));
+        let includedir = prefix.join(get_path_or(args, "includedir", || {
+            rustc_target.default_includedir()
+        }));
+        let datarootdir = prefix.join(get_path_or(args, "datarootdir", || {
+            rustc_target.default_datadir()
+        }));
         let datadir = args
             .get_one::<PathBuf>("datadir")
             .map(|d| prefix.join(d))

src/target.rs

@@ -20,14 +20,16 @@ pub struct Target {
 
 impl Target {
     pub fn new<T: AsRef<std::ffi::OsStr>>(
-        target: T,
+        target: Option<T>,
         is_target_overridden: bool,
     ) -> Result<Self, anyhow::Error> {
         let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
         let mut cmd = std::process::Command::new(rustc);
 
         cmd.arg("--print").arg("cfg");
-        cmd.arg("--target").arg(target);
+        if let Some(target) = target {
+            cmd.arg("--target").arg(target);
+        }
 
         let out = cmd.output()?;
         if out.status.success() {
@@ -120,12 +122,6 @@ impl Target {
         lines
     }
 
-    fn is_debianlike(&self) -> bool {
-        consts::ARCH.eq_ignore_ascii_case(&self.arch)
-            && consts::OS.eq_ignore_ascii_case(&self.os)
-            && PathBuf::from("/etc/debian_version").exists()
-    }
-
     fn is_freebsd(&self) -> bool {
         self.os.eq_ignore_ascii_case("freebsd")
     }
@@ -143,7 +139,7 @@ impl Target {
             return "lib".into();
         }
 
-        if self.is_debianlike() {
+        if PathBuf::from("/etc/debian_version").exists() {
             let pc = std::process::Command::new("dpkg-architecture")
                 .arg("-qDEB_HOST_MULTIARCH")
                 .output();