Add missing dependency fields and follow cargo's dependency renaming rules

Author: Niki4tap

Cargo.toml

@@ -9,4 +9,4 @@ members = [
 ]
 
 [workspace.metadata.marker.lints]
-dogfood = { path = "marker_lints" }
+marker_lints = { path = "marker_lints" }

cargo-marker/src/config.rs

@@ -33,6 +33,7 @@ pub enum LintDependency {
 #[serde(deny_unknown_fields)]
 pub struct LintDependencyEntry {
     path: Option<String>,
+    package: Option<String>,
     // TODO: Everything below is not yet supported
     // Registry fetching:
     version: Option<String>,
@@ -42,6 +43,8 @@ pub struct LintDependencyEntry {
     rev: Option<String>,
     branch: Option<String>,
     // Features:
+    #[serde(rename = "default-features")]
+    default_features: Option<bool>,
     features: Option<Vec<String>>,
     optional: Option<bool>,
     // TODO: do we want lint configuration here too?
@@ -115,7 +118,7 @@ impl Config {
         Ok(marker_config)
     }
 
-    pub fn collect_paths(&self) -> Result<Vec<String>, ExitStatus> {
+    pub fn collect_crates(&self) -> Result<Vec<(String, String)>, ExitStatus> {
         self.lints
             .iter()
             .map(|(name, dep)| match dep {
@@ -131,12 +134,16 @@ impl Config {
                             git,
                             rev,
                             branch,
+                            default_features,
                             features,
                             optional
                         ]
                     );
                     if let Some(ref path) = dep.path {
-                        return Ok(path.clone());
+                        if let Some(ref package) = dep.package {
+                            return Ok((package.clone(), path.clone()));
+                        }
+                        return Ok((name.clone(), path.clone()));
                     }
                     eprintln!("No `path` field found for lint crate {name}");
                     Err(ExitStatus::BadConfiguration)

cargo-marker/src/lints.rs

@@ -8,20 +8,30 @@ use crate::ExitStatus;
 
 /// This creates a debug build for a local crate. The path of the build library
 /// will be returned, if the operation was successful.
-pub fn build_local_lint_crate(crate_dir: &Path, target_dir: &Path, verbose: bool) -> Result<PathBuf, ExitStatus> {
+pub fn build_local_lint_crate(
+    package_name: Option<&str>,
+    crate_dir: &Path,
+    target_dir: &Path,
+    verbose: bool,
+) -> Result<PathBuf, ExitStatus> {
     if !crate_dir.exists() {
         eprintln!("The given lint can't be found, searched at: `{}`", crate_dir.display());
         return Err(ExitStatus::LintCrateNotFound);
     }
 
     // Compile the lint crate
     let mut cmd = Command::new("cargo");
+    cmd.arg("build");
     if verbose {
         cmd.arg("--verbose");
     }
+    if let Some(name) = package_name {
+        cmd.arg("--package");
+        cmd.arg(name);
+    }
     let exit_status = cmd
         .current_dir(std::fs::canonicalize(crate_dir).unwrap())
-        .args(["build", "--lib", "--target-dir"])
+        .args(["--lib", "--target-dir"])
         .arg(target_dir.as_os_str())
         .env("RUSTFLAGS", "--cap-lints=allow")
         .spawn()

cargo-marker/src/main.rs

@@ -79,12 +79,19 @@ fn prepare_lint_build_dir(dir_name: &str, info_name: &str) -> String {
         .to_string()
 }
 
-fn choose_lint_crates(args: &clap::ArgMatches, config: Option<Config>) -> Result<Vec<OsString>, ExitStatus> {
-    let lint_crates: Vec<OsString> = match args.get_many::<OsString>("lints") {
-        Some(v) => v.cloned().collect(),
+fn choose_lint_crates(
+    args: &clap::ArgMatches,
+    config: Option<Config>,
+) -> Result<Vec<(Option<String>, OsString)>, ExitStatus> {
+    let lint_crates: Vec<(Option<String>, OsString)> = match args.get_many::<OsString>("lints") {
+        Some(v) => v.cloned().map(|v| (None, v)).collect(),
         None => {
             if let Some(config) = config {
-                config.collect_paths()?.iter().map(Into::into).collect()
+                config
+                    .collect_crates()?
+                    .into_iter()
+                    .map(|(name, path)| (Some(name), path.into()))
+                    .collect()
             } else {
                 eprintln!(
                     "Please provide at least one valid lint crate, with the `--lints` argument, or `[workspace.metadata.marker.lints]` in `Cargo.toml`"
@@ -130,7 +137,7 @@ fn main() -> Result<(), ExitStatus> {
 }
 
 fn run_check(
-    lint_crate_paths: &[OsString],
+    crate_entries: &[(Option<String>, OsString)],
     verbose: bool,
     dev_build: bool,
     test_build: bool,
@@ -140,26 +147,34 @@ fn run_check(
         driver::install_driver(verbose, dev_build)?;
     }
 
-    if lint_crate_paths.is_empty() {
+    if crate_entries.is_empty() {
         eprintln!(
             "Please provide at least one valid lint crate, with the `--lints` argument, or `[workspace.metadata.marker.lints]` in `Cargo.toml`"
         );
         return Err(ExitStatus::NoLints);
     }
 
-    if lint_crate_paths.iter().any(|path| path.to_string_lossy().contains(';')) {
+    if crate_entries
+        .iter()
+        .any(|(_name, path)| path.to_string_lossy().contains(';'))
+    {
         eprintln!("The absolute paths of lint crates are not allowed to contain a `;`");
         return Err(ExitStatus::InvalidValue);
     }
 
-    let mut lint_crates = Vec::with_capacity(lint_crate_paths.len());
+    let mut lint_crates = Vec::with_capacity(crate_entries.len());
 
     println!();
     println!("Compiling Lints:");
     let target_dir = Path::new(&*MARKER_LINT_DIR);
-    for krate in lint_crate_paths {
-        let src_dir = PathBuf::from(krate);
-        let crate_file = build_local_lint_crate(src_dir.as_path(), target_dir, verbose)?;
+    for (name, path) in crate_entries {
+        let src_dir = PathBuf::from(path);
+        let crate_file = build_local_lint_crate(
+            name.as_ref().map(String::as_str),
+            src_dir.as_path(),
+            target_dir,
+            verbose,
+        )?;
         lint_crates.push(crate_file.as_os_str().to_os_string());
     }