cargo can silently fix some bad lockfiles (use --locked to disable)

src/cargo/core/resolver/encode.rs

@@ -30,7 +30,7 @@ struct Patch {
 pub type Metadata = BTreeMap<String, String>;
 
 impl EncodableResolve {
-    pub fn into_resolve(self, ws: &Workspace) -> CargoResult<Resolve> {
+    pub fn into_resolve(self, ws: &Workspace, ignore_errors: bool) -> CargoResult<Resolve> {
         let path_deps = build_path_deps(ws);
 
         let packages = {
@@ -74,18 +74,27 @@ impl EncodableResolve {
             (live_pkgs, all_pkgs)
         };
 
-        let lookup_id = |enc_id: &EncodablePackageId| -> CargoResult<Option<PackageId>> {
+        let lookup_id = |enc_id: &EncodablePackageId,
+                         dependent_pkg: Option<&PackageId>|
+         -> CargoResult<Option<PackageId>> {
             match live_pkgs.get(enc_id) {
                 Some(&(ref id, _)) => Ok(Some(id.clone())),
                 None => if all_pkgs.contains(enc_id) {
                     // Package is found in the lockfile, but it is
                     // no longer a member of the workspace.
                     Ok(None)
+                } else if ignore_errors {
+                    // We are asked to ignore errors
+                    Ok(None)
                 } else {
+                    let suggestion = dependent_pkg
+                        .map(|p| format!("\n  consider running 'cargo update -p {}'", p.name()))
+                        .unwrap_or_default();
                     bail!(
                         "package `{}` is specified as a dependency, \
-                         but is missing from the package list",
-                        enc_id
+                         but is missing from the package list{}",
+                        enc_id,
+                        suggestion,
                     );
                 },
             }
@@ -105,7 +114,7 @@ impl EncodableResolve {
                 };
 
                 for edge in deps.iter() {
-                    if let Some(to_depend_on) = lookup_id(edge)? {
+                    if let Some(to_depend_on) = lookup_id(edge, Some(id))? {
                         g.link(id.clone(), to_depend_on);
                     }
                 }
@@ -118,7 +127,7 @@ impl EncodableResolve {
             for &(ref id, pkg) in live_pkgs.values() {
                 if let Some(ref replace) = pkg.replace {
                     assert!(pkg.dependencies.is_none());
-                    if let Some(replace_id) = lookup_id(replace)? {
+                    if let Some(replace_id) = lookup_id(replace, Some(id))? {
                         replacements.insert(id.clone(), replace_id);
                     }
                 }
@@ -151,7 +160,7 @@ impl EncodableResolve {
             let k = &k[prefix.len()..];
             let enc_id: EncodablePackageId = k.parse()
                 .chain_err(|| internal("invalid encoding of checksum in lockfile"))?;
-            let id = match lookup_id(&enc_id) {
+            let id = match lookup_id(&enc_id, None) {
                 Ok(Some(id)) => id,
                 _ => continue,
             };

src/cargo/ops/cargo_generate_lockfile.rs

@@ -46,7 +46,8 @@ pub fn update_lockfile(ws: &Workspace, opts: &UpdateOptions) -> CargoResult<()>
         bail!("you can't update in the offline mode");
     }
 
-    let previous_resolve = match ops::load_pkg_lockfile(ws)? {
+    // `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)? {
         Some(resolve) => resolve,
         None => return generate_lockfile(ws),
     };

src/cargo/ops/cargo_pkgid.rs

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

src/cargo/ops/lockfile.rs

@@ -8,7 +8,7 @@ use util::Filesystem;
 use util::errors::{CargoResult, CargoResultExt};
 use util::toml as cargo_toml;
 
-pub fn load_pkg_lockfile(ws: &Workspace) -> CargoResult<Option<Resolve>> {
+pub fn load_pkg_lockfile(ws: &Workspace, ignore_errors: bool) -> CargoResult<Option<Resolve>> {
     if !ws.root().join("Cargo.lock").exists() {
         return Ok(None);
     }
@@ -24,7 +24,7 @@ pub fn load_pkg_lockfile(ws: &Workspace) -> CargoResult<Option<Resolve>> {
         (|| -> CargoResult<Option<Resolve>> {
             let resolve: toml::Value = cargo_toml::parse(&s, f.path(), ws.config())?;
             let v: resolver::EncodableResolve = resolve.try_into()?;
-            Ok(Some(v.into_resolve(ws)?))
+            Ok(Some(v.into_resolve(ws, ignore_errors)?))
         })()
             .chain_err(|| format!("failed to parse lock file at: {}", f.path().display()))?;
     Ok(resolve)
@@ -115,7 +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)?;
-            Ok(old.into_resolve(ws)? == new.into_resolve(ws)?)
+            // `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)?)
         })();
         if let Ok(true) = res {
             return true;

src/cargo/ops/resolve.rs

@@ -82,7 +82,7 @@ pub fn resolve_ws_with_method<'a>(
 
         Some(resolve)
     } else {
-        ops::load_pkg_lockfile(ws)?
+        ops::load_pkg_lockfile(ws, false)?
     };
 
     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)?;
+    let prev = ops::load_pkg_lockfile(ws, false)?;
     let resolve = resolve_with_previous(
         registry,
         ws,

tests/testsuite/bad_config.rs

@@ -379,9 +379,15 @@ fn bad_dependency_in_lockfile() {
 
 Caused by:
   package `bar 0.1.0 ([..])` is specified as a dependency, but is missing from the package list
+  consider running 'cargo update -p foo'
 ",
         ),
     );
+
+    assert_that(
+        p.cargo("update -p foo"),
+        execs().with_status(0),
+    );
 }
 
 #[test]