Introduce LibRule::Default to avoid failure mode

The other targets have a no-failure FilterRule::All, but if lib is true
and the crate doesn't have a library, then generate_targets fails hard.
Let's give library a flexible option.

Author: dwijnand

src/bin/cargo/commands/fix.rs

@@ -1,6 +1,6 @@
 use crate::command_prelude::*;
 
-use cargo::ops::{self, CompileFilter, FilterRule};
+use cargo::ops::{self, CompileFilter, FilterRule, LibRule};
 
 pub fn cli() -> App {
     subcommand("fix")
@@ -127,7 +127,7 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     if let CompileFilter::Default { .. } = opts.filter {
         opts.filter = CompileFilter::Only {
             all_targets: true,
-            lib: true,
+            lib: LibRule::Default,
             bins: FilterRule::All,
             examples: FilterRule::All,
             benches: FilterRule::All,

src/bin/cargo/commands/test.rs

@@ -1,4 +1,4 @@
-use cargo::ops::{self, CompileFilter, FilterRule};
+use cargo::ops::{self, CompileFilter, FilterRule, LibRule};
 
 use crate::command_prelude::*;
 
@@ -111,7 +111,7 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
         }
         compile_opts.build_config.mode = CompileMode::Doctest;
         compile_opts.filter = ops::CompileFilter::new(
-            true,
+            LibRule::True,
             FilterRule::none(),
             FilterRule::none(),
             FilterRule::none(),

src/cargo/ops/cargo_compile.rs

@@ -172,6 +172,16 @@ impl Packages {
     }
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum LibRule {
+    /// Include the library, fail if not present
+    True,
+    /// Include the library if present
+    Default,
+    /// Exclude the library
+    False,
+}
+
 #[derive(Debug)]
 pub enum FilterRule {
     All,
@@ -186,7 +196,7 @@ pub enum CompileFilter {
     },
     Only {
         all_targets: bool,
-        lib: bool,
+        lib: LibRule,
         bins: FilterRule,
         examples: FilterRule,
         tests: FilterRule,
@@ -389,6 +399,7 @@ impl CompileFilter {
         all_bens: bool,
         all_targets: bool,
     ) -> CompileFilter {
+        let rule_lib = if lib_only { LibRule::True } else { LibRule::False };
         let rule_bins = FilterRule::new(bins, all_bins);
         let rule_tsts = FilterRule::new(tsts, all_tsts);
         let rule_exms = FilterRule::new(exms, all_exms);
@@ -397,34 +408,34 @@ impl CompileFilter {
         if all_targets {
             CompileFilter::Only {
                 all_targets: true,
-                lib: true,
+                lib: LibRule::Default,
                 bins: FilterRule::All,
                 examples: FilterRule::All,
                 benches: FilterRule::All,
                 tests: FilterRule::All,
             }
         } else {
-            CompileFilter::new(lib_only, rule_bins, rule_tsts, rule_exms, rule_bens)
+            CompileFilter::new(rule_lib, rule_bins, rule_tsts, rule_exms, rule_bens)
         }
     }
 
     /// Construct a CompileFilter from underlying primitives.
     pub fn new(
-        lib_only: bool,
+        rule_lib: LibRule,
         rule_bins: FilterRule,
         rule_tsts: FilterRule,
         rule_exms: FilterRule,
         rule_bens: FilterRule,
     ) -> CompileFilter {
-        if lib_only
+        if rule_lib == LibRule::True
             || rule_bins.is_specific()
             || rule_tsts.is_specific()
             || rule_exms.is_specific()
             || rule_bens.is_specific()
         {
             CompileFilter::Only {
                 all_targets: false,
-                lib: lib_only,
+                lib: rule_lib,
                 bins: rule_bins,
                 examples: rule_exms,
                 benches: rule_bens,
@@ -460,7 +471,7 @@ impl CompileFilter {
         match *self {
             CompileFilter::Default { .. } => true,
             CompileFilter::Only {
-                lib,
+                ref lib,
                 ref bins,
                 ref examples,
                 ref tests,
@@ -472,7 +483,11 @@ impl CompileFilter {
                     TargetKind::Test => tests,
                     TargetKind::Bench => benches,
                     TargetKind::ExampleBin | TargetKind::ExampleLib(..) => examples,
-                    TargetKind::Lib(..) => return lib,
+                    TargetKind::Lib(..) => return match *lib {
+                        LibRule::True => true,
+                        LibRule::Default => true,
+                        LibRule::False => false,
+                    },
                     TargetKind::CustomBuild => return false,
                 };
                 rule.matches(target)
@@ -626,13 +641,13 @@ fn generate_targets<'a>(
         }
         CompileFilter::Only {
             all_targets,
-            lib,
+            ref lib,
             ref bins,
             ref examples,
             ref tests,
             ref benches,
         } => {
-            if lib {
+            if *lib != LibRule::False {
                 let mut libs = Vec::new();
                 for proposal in filter_targets(packages, Target::is_lib, false, build_config.mode) {
                     let Proposal { target, pkg, .. } = proposal;
@@ -646,7 +661,7 @@ fn generate_targets<'a>(
                         libs.push(proposal)
                     }
                 }
-                if !all_targets && libs.is_empty() {
+                if !all_targets && libs.is_empty() && *lib == LibRule::True {
                     let names = packages.iter().map(|pkg| pkg.name()).collect::<Vec<_>>();
                     if names.len() == 1 {
                         failure::bail!("no library targets found in package `{}`", names[0]);

src/cargo/ops/mod.rs

@@ -1,6 +1,6 @@
 pub use self::cargo_clean::{clean, CleanOptions};
 pub use self::cargo_compile::{compile, compile_with_exec, compile_ws, CompileOptions};
-pub use self::cargo_compile::{CompileFilter, FilterRule, Packages};
+pub use self::cargo_compile::{CompileFilter, FilterRule, LibRule, Packages};
 pub use self::cargo_doc::{doc, DocOptions};
 pub use self::cargo_fetch::{fetch, FetchOptions};
 pub use self::cargo_generate_lockfile::generate_lockfile;