Start migration to the failure crate

This commit is the initial steps to migrate Cargo's error handling from the
`error-chain` crate to the `failure` crate. This is intended to be a low-cost
(in terms of diff) transition where possible so it's note "purely idiomatic
`failure` crate" just yet.

The `error-chain` dependency is dropped in this commit and Cargo now canonically
uses the `Error` type from the `failure` crate. The main last remnant of
`error-chain` is a custom local extension trait to use `chain_err` instead of
`with_context`. I'll try to follow up with a commit that renames this later but
I wanted to make sure everything worked first! (and `chain_err` is used
practically everywhere).

Some minor tweaks happened in the tests as I touched up a few error messages
here and there but overall the UI of Cargo should be exactly the same before and
after this commit.

Author: alexcrichton

Cargo.toml

@@ -24,7 +24,7 @@ crypto-hash = "0.3"
 curl = "0.4.6"
 docopt = "0.8.1"
 env_logger = "0.4"
-error-chain = "0.11.0"
+failure = "0.1.1"
 filetime = "0.1"
 flate2 = "0.2"
 fs2 = "0.4"

src/bin/bench.rs

@@ -2,7 +2,7 @@ use std::env;
 
 use cargo::core::Workspace;
 use cargo::ops::{self, MessageFormat, Packages};
-use cargo::util::{CliResult, CliError, Config, CargoErrorKind};
+use cargo::util::{CliResult, CliError, Config};
 use cargo::util::important_paths::{find_root_manifest_for_wd};
 
 #[derive(Deserialize)]
@@ -144,8 +144,8 @@ pub fn execute(options: Options, config: &mut Config) -> CliResult {
         None => Ok(()),
         Some(err) => {
             Err(match err.exit.as_ref().and_then(|e| e.code()) {
-                Some(i) => CliError::new("bench failed".into(), i),
-                None => CliError::new(CargoErrorKind::CargoTestErrorKind(err).into(), 101)
+                Some(i) => CliError::new(format_err!("bench failed"), i),
+                None => CliError::new(err.into(), 101)
             })
         }
     }

src/bin/cargo.rs

@@ -1,5 +1,7 @@
 extern crate cargo;
 extern crate env_logger;
+#[macro_use]
+extern crate failure;
 extern crate git2_curl;
 extern crate toml;
 #[macro_use]
@@ -15,8 +17,8 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 use cargo::core::shell::{Shell, Verbosity};
-use cargo::util::{self, CliResult, lev_distance, Config, CargoResult, CargoError, CargoErrorKind};
-use cargo::util::CliError;
+use cargo::util::{self, CliResult, lev_distance, Config, CargoResult};
+use cargo::util::{CliError, ProcessError};
 
 #[derive(Deserialize)]
 pub struct Flags {
@@ -87,7 +89,7 @@ fn main() {
         let args: Vec<_> = try!(env::args_os()
             .map(|s| {
                 s.into_string().map_err(|s| {
-                    CargoError::from(format!("invalid unicode in argument: {:?}", s))
+                    format_err!("invalid unicode in argument: {:?}", s)
                 })
             })
             .collect());
@@ -315,15 +317,15 @@ fn execute_external_subcommand(config: &Config, cmd: &str, args: &[String]) -> C
     let command = match path {
         Some(command) => command,
         None => {
-            return Err(CargoError::from(match find_closest(config, cmd) {
-                    Some(closest) => {
-                        format!("no such subcommand: `{}`\n\n\tDid you mean `{}`?\n",
+            let err = match find_closest(config, cmd) {
+                Some(closest) => {
+                    format_err!("no such subcommand: `{}`\n\n\tDid you mean `{}`?\n",
                                 cmd,
                                 closest)
-                    }
-                    None => format!("no such subcommand: `{}`", cmd),
-                })
-                .into())
+                }
+                None => format_err!("no such subcommand: `{}`", cmd),
+            };
+            return Err(CliError::new(err, 101))
         }
     };
 
@@ -336,7 +338,7 @@ fn execute_external_subcommand(config: &Config, cmd: &str, args: &[String]) -> C
         Err(e) => e,
     };
 
-    if let &CargoErrorKind::ProcessErrorKind(ref perr) = err.kind() {
+    if let Some(perr) = err.downcast_ref::<ProcessError>() {
         if let Some(code) = perr.exit.as_ref().and_then(|c| c.code()) {
             return Err(CliError::code(code));
         }

src/bin/check.rs

@@ -114,8 +114,8 @@ pub fn execute(options: Options, config: &mut Config) -> CliResult {
             Some("test") => true,
             None => false,
             Some(profile) => {
-                let err = format!("unknown profile: `{}`, only `test` is currently supported",
-                                  profile).into();
+                let err = format_err!("unknown profile: `{}`, only `test` is \
+                                       currently supported", profile);
                 return Err(CliError::new(err, 101))
             }
         };

src/bin/help.rs

@@ -18,5 +18,6 @@ pub fn execute(_: Options, _: &mut Config) -> CliResult {
     // This is a dummy command just so that `cargo help help` works.
     // The actual delegation of help flag to subcommands is handled by the
     // cargo command.
-    Err(CliError::new("help command should not be executed directly".into(), 101))
+    Err(CliError::new(format_err!("help command should not be executed directly"),
+                      101))
 }

src/bin/install.rs

@@ -1,6 +1,6 @@
 use cargo::ops;
 use cargo::core::{SourceId, GitReference};
-use cargo::util::{CargoError, CliResult, Config, ToUrl};
+use cargo::util::{CliResult, Config, ToUrl};
 
 #[derive(Deserialize)]
 pub struct Options {
@@ -154,7 +154,7 @@ pub fn execute(options: Options, config: &mut Config) -> CliResult {
 
     let krates = options.arg_crate.iter().map(|s| &s[..]).collect::<Vec<_>>();
     let vers = match (&options.flag_vers, &options.flag_version) {
-        (&Some(_), &Some(_)) => return Err(CargoError::from("Invalid arguments.").into()),
+        (&Some(_), &Some(_)) => return Err(format_err!("invalid arguments").into()),
         (&Some(ref v), _) | (_, &Some(ref v)) => Some(v.as_ref()),
         _ => None,
     };

src/bin/locate_project.rs

@@ -27,9 +27,9 @@ pub fn execute(flags: LocateProjectFlags, config: &mut Config) -> CliResult {
     let root = find_root_manifest_for_wd(flags.flag_manifest_path, config.cwd())?;
 
     let string = root.to_str()
-                      .ok_or_else(|| "Your project path contains \
-                                             characters not representable in \
-                                             Unicode".into())
+                      .ok_or_else(|| format_err!("your project path contains \
+                                                  characters not representable in \
+                                                  Unicode"))
                       .map_err(|e| CliError::new(e, 1))?;
 
     let location = ProjectLocation { root: string.to_string() };

src/bin/login.rs

@@ -4,7 +4,7 @@ use std::io;
 use cargo::ops;
 use cargo::core::{SourceId, Source};
 use cargo::sources::RegistrySource;
-use cargo::util::{CargoError, CliResult, CargoResultExt, Config};
+use cargo::util::{CliResult, CargoResultExt, Config, CargoError};
 
 #[derive(Deserialize)]
 pub struct Options {
@@ -48,15 +48,17 @@ pub fn execute(options: Options, config: &mut Config) -> CliResult {
                      &options.flag_z)?;
 
     if options.flag_registry.is_some() && !config.cli_unstable().unstable_options {
-        return Err(CargoError::from("registry option is an unstable feature and requires -Zunstable-options to use.").into());
+        return Err(format_err!("registry option is an unstable feature and \
+                                requires -Zunstable-options to use.").into());
     }
 
     let token = match options.arg_token {
         Some(token) => token,
         None => {
             let host = match options.flag_registry {
                 Some(ref _registry) => {
-                    return Err(CargoError::from("token must be provided when --registry is provided.").into());
+                    return Err(format_err!("token must be provided when \
+                                            --registry is provided.").into())
                 }
                 None => {
                     let src = SourceId::crates_io(config)?;
@@ -71,7 +73,7 @@ pub fn execute(options: Options, config: &mut Config) -> CliResult {
             let input = io::stdin();
             input.lock().read_line(&mut line).chain_err(|| {
                 "failed to read stdin"
-            })?;
+            }).map_err(CargoError::from)?;
             line.trim().to_string()
         }
     };

src/bin/owner.rs

@@ -1,5 +1,5 @@
 use cargo::ops;
-use cargo::util::{CargoError, CliResult, Config};
+use cargo::util::{CliResult, Config};
 
 #[derive(Deserialize)]
 pub struct Options {
@@ -67,7 +67,8 @@ pub fn execute(options: Options, config: &mut Config) -> CliResult {
     };
 
     if opts.registry.is_some() && !config.cli_unstable().unstable_options {
-        return Err(CargoError::from("registry option is an unstable feature and requires -Zunstable-options to use.").into());
+        return Err(format_err!("registry option is an unstable feature and \
+                                requires -Zunstable-options to use.").into())
     }
 
     ops::modify_owners(config, &opts)?;

src/bin/publish.rs

@@ -1,6 +1,6 @@
 use cargo::core::Workspace;
 use cargo::ops;
-use cargo::util::{CargoError, CliResult, Config};
+use cargo::util::{CliResult, Config};
 use cargo::util::important_paths::find_root_manifest_for_wd;
 
 #[derive(Deserialize)]
@@ -74,7 +74,8 @@ pub fn execute(options: Options, config: &mut Config) -> CliResult {
     } = options;
 
     if registry.is_some() && !config.cli_unstable().unstable_options {
-        return Err(CargoError::from("registry option is an unstable feature and requires -Zunstable-options to use.").into());
+        return Err(format_err!("registry option is an unstable feature and \
+                                requires -Zunstable-options to use.").into())
     }
 
     // TODO: Deprecated