use enum instead of bool

src/cargo/core/resolver/encode.rs

@@ -29,8 +29,23 @@ struct Patch {
 
 pub type Metadata = BTreeMap<String, String>;
 
+pub enum ErrorHandle{
+    Ignore,
+    Raise,
+}
+
+impl ErrorHandle {
+    fn is_ignore(&self) -> bool {
+        use self::ErrorHandle::*;
+        match self {
+            Ignore => true,
+            Raise => false,
+        }
+    }
+}
+
 impl EncodableResolve {
-    pub fn into_resolve(self, ws: &Workspace, ignore_errors: bool) -> CargoResult<Resolve> {
+    pub fn into_resolve(self, ws: &Workspace, ignore_errors: ErrorHandle) -> CargoResult<Resolve> {
         let path_deps = build_path_deps(ws);
 
         let packages = {
@@ -83,7 +98,7 @@ impl EncodableResolve {
                     // Package is found in the lockfile, but it is
                     // no longer a member of the workspace.
                     Ok(None)
-                } else if ignore_errors {
+                } else if ignore_errors.is_ignore() {
                     // We are asked to ignore errors
                     Ok(None)
                 } else {

src/cargo/core/resolver/mod.rs

@@ -66,7 +66,7 @@ use self::context::{Activations, Context};
 use self::types::{ActivateError, ActivateResult, Candidate, ConflictReason, DepsFrame, GraphNode};
 use self::types::{RcVecIter, RegistryQueryer};
 
-pub use self::encode::{EncodableDependency, EncodablePackageId, EncodableResolve};
+pub use self::encode::{EncodableDependency, EncodablePackageId, EncodableResolve, ErrorHandle};
 pub use self::encode::{Metadata, WorkspaceResolve};
 pub use self::resolve::{Deps, DepsNotReplaced, Resolve};
 pub use self::types::Method;

src/cargo/ops/cargo_generate_lockfile.rs

@@ -5,7 +5,7 @@ use termcolor::Color::{self, Cyan, Green, Red};
 use core::PackageId;
 use core::registry::PackageRegistry;
 use core::{Resolve, SourceId, Workspace};
-use core::resolver::Method;
+use core::resolver::{Method, ErrorHandle};
 use ops;
 use util::config::Config;
 use util::CargoResult;
@@ -46,8 +46,8 @@ pub fn update_lockfile(ws: &Workspace, opts: &UpdateOptions) -> CargoResult<()>
         bail!("you can't update in the offline mode");
     }
 
-    // `ignore_errors` is set to true, because we are about to clean the errors up.
-    let previous_resolve = match ops::load_pkg_lockfile(ws, true)? {
+    // ignore errors, because we are about to clean them up.
+    let previous_resolve = match ops::load_pkg_lockfile(ws, ErrorHandle::Ignore)? {
         Some(resolve) => resolve,
         None => return generate_lockfile(ws),
     };

src/cargo/ops/cargo_pkgid.rs

@@ -1,9 +1,10 @@
 use ops;
 use core::{PackageIdSpec, Workspace};
+use core::resolver::ErrorHandle;
 use util::CargoResult;
 
 pub fn pkgid(ws: &Workspace, spec: Option<&str>) -> CargoResult<PackageIdSpec> {
-    let resolve = match ops::load_pkg_lockfile(ws, false)? {
+    let resolve = match ops::load_pkg_lockfile(ws, ErrorHandle::Raise)? {
         Some(resolve) => resolve,
         None => bail!("a Cargo.lock must exist for this command"),
     };

src/cargo/ops/lockfile.rs

@@ -3,12 +3,12 @@ use std::io::prelude::*;
 use toml;
 
 use core::{resolver, Resolve, Workspace};
-use core::resolver::WorkspaceResolve;
+use core::resolver::{WorkspaceResolve, ErrorHandle};
 use util::Filesystem;
 use util::errors::{CargoResult, CargoResultExt};
 use util::toml as cargo_toml;
 
-pub fn load_pkg_lockfile(ws: &Workspace, ignore_errors: bool) -> CargoResult<Option<Resolve>> {
+pub fn load_pkg_lockfile(ws: &Workspace, ignore_errors: ErrorHandle) -> CargoResult<Option<Resolve>> {
     if !ws.root().join("Cargo.lock").exists() {
         return Ok(None);
     }
@@ -115,8 +115,8 @@ fn are_equal_lockfiles(mut orig: String, current: &str, ws: &Workspace) -> bool
         let res: CargoResult<bool> = (|| {
             let old: resolver::EncodableResolve = toml::from_str(&orig)?;
             let new: resolver::EncodableResolve = toml::from_str(current)?;
-            // `ignore_errors` is set to true, because we may be about to clean the errors up.
-            Ok(old.into_resolve(ws, true)? == new.into_resolve(ws, true)?)
+            // ignore errors, because we may be about to clean them up.
+            Ok(old.into_resolve(ws, ErrorHandle::Ignore)? == new.into_resolve(ws, ErrorHandle::Ignore)?)
         })();
         if let Ok(true) = res {
             return true;

src/cargo/ops/resolve.rs

@@ -2,7 +2,7 @@ use std::collections::HashSet;
 
 use core::{PackageId, PackageIdSpec, PackageSet, Source, SourceId, Workspace};
 use core::registry::PackageRegistry;
-use core::resolver::{self, Method, Resolve};
+use core::resolver::{self, Method, Resolve, ErrorHandle};
 use sources::PathSource;
 use ops;
 use util::profile;
@@ -82,7 +82,7 @@ pub fn resolve_ws_with_method<'a>(
 
         Some(resolve)
     } else {
-        ops::load_pkg_lockfile(ws, false)?
+        ops::load_pkg_lockfile(ws, ErrorHandle::Raise)?
     };
 
     let resolved_with_overrides = ops::resolve_with_previous(
@@ -106,7 +106,7 @@ fn resolve_with_registry<'cfg>(
     registry: &mut PackageRegistry<'cfg>,
     warn: bool,
 ) -> CargoResult<Resolve> {
-    let prev = ops::load_pkg_lockfile(ws, false)?;
+    let prev = ops::load_pkg_lockfile(ws, ErrorHandle::Raise)?;
     let resolve = resolve_with_previous(
         registry,
         ws,