Add error-chain errors.

Cargo.toml

@@ -22,6 +22,7 @@ crossbeam = "0.2"
 curl = "0.4.6"
 docopt = "0.7"
 env_logger = "0.4"
+error-chain = "0.10.0"
 filetime = "0.1"
 flate2 = "0.2"
 fs2 = "0.4"

src/bin/bench.rs

@@ -1,6 +1,6 @@
 use cargo::core::Workspace;
 use cargo::ops::{self, MessageFormat, Packages};
-use cargo::util::{CliResult, CliError, Human, Config, human};
+use cargo::util::{CliResult, CliError, Config, CargoErrorKind};
 use cargo::util::important_paths::{find_root_manifest_for_wd};
 
 #[derive(RustcDecodable)]
@@ -128,8 +128,8 @@ pub fn execute(options: Options, config: &Config) -> CliResult {
         None => Ok(()),
         Some(err) => {
             Err(match err.exit.as_ref().and_then(|e| e.code()) {
-                Some(i) => CliError::new(human("bench failed"), i),
-                None => CliError::new(Box::new(Human(err)), 101)
+                Some(i) => CliError::new("bench failed".into(), i),
+                None => CliError::new(CargoErrorKind::CargoTestErrorKind(err).into(), 101)
             })
         }
     }

src/bin/cargo.rs

@@ -17,7 +17,7 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 use cargo::core::shell::{Verbosity, ColorConfig};
-use cargo::util::{self, CliResult, lev_distance, Config, human, CargoResult};
+use cargo::util::{self, CliResult, lev_distance, Config, CargoResult, CargoError, CargoErrorKind};
 use cargo::util::CliError;
 
 #[derive(RustcDecodable)]
@@ -84,7 +84,9 @@ fn main() {
     let result = (|| {
         let args: Vec<_> = try!(env::args_os()
             .map(|s| {
-                s.into_string().map_err(|s| human(format!("invalid unicode in argument: {:?}", s)))
+                s.into_string().map_err(|s| {
+                    CargoError::from(format!("invalid unicode in argument: {:?}", s))
+                })
             })
             .collect());
         let rest = &args;
@@ -180,7 +182,7 @@ fn execute(flags: Flags, config: &Config) -> CliResult {
 
     if let Some(ref code) = flags.flag_explain {
         let mut procss = config.rustc()?.process();
-        procss.arg("--explain").arg(code).exec().map_err(human)?;
+        procss.arg("--explain").arg(code).exec()?;
         return Ok(());
     }
 
@@ -309,7 +311,7 @@ fn execute_external_subcommand(config: &Config, cmd: &str, args: &[String]) -> C
     let command = match path {
         Some(command) => command,
         None => {
-            return Err(human(match find_closest(config, cmd) {
+            return Err(CargoError::from(match find_closest(config, cmd) {
                     Some(closest) => {
                         format!("no such subcommand: `{}`\n\n\tDid you mean `{}`?\n",
                                 cmd,
@@ -330,11 +332,12 @@ fn execute_external_subcommand(config: &Config, cmd: &str, args: &[String]) -> C
         Err(e) => e,
     };
 
-    if let Some(code) = err.exit.as_ref().and_then(|c| c.code()) {
-        Err(CliError::code(code))
-    } else {
-        Err(CliError::new(Box::new(err), 101))
+    if let CargoError(CargoErrorKind::ProcessErrorKind(ref perr), ..) = err {
+        if let Some(code) = perr.exit.as_ref().and_then(|c| c.code()) {
+            return Err(CliError::code(code));
+        }
     }
+    Err(CliError::new(err, 101))    
 }
 
 /// List all runnable commands

src/bin/help.rs

@@ -1,4 +1,4 @@
-use cargo::util::{CliResult, CliError, Config, human};
+use cargo::util::{CliResult, CliError, Config};
 
 #[derive(RustcDecodable)]
 pub struct Options;
@@ -18,5 +18,5 @@ pub fn execute(_: Options, _: &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(human("help command should not be executed directly"), 101))
+    Err(CliError::new("help command should not be executed directly".into(), 101))
 }

src/bin/locate_project.rs

@@ -1,5 +1,5 @@
 use cargo;
-use cargo::util::{CliResult, CliError, human, ChainError, Config};
+use cargo::util::{CliResult, CliError, Config};
 use cargo::util::important_paths::{find_root_manifest_for_wd};
 
 #[derive(RustcDecodable)]
@@ -28,9 +28,9 @@ pub fn execute(flags: LocateProjectFlags,
     let root = find_root_manifest_for_wd(flags.flag_manifest_path, config.cwd())?;
 
     let string = root.to_str()
-                      .chain_error(|| human("Your project path contains \
+                      .ok_or_else(|| "Your project path contains \
                                              characters not representable in \
-                                             Unicode"))
+                                             Unicode".into())
                       .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::{CliResult, Config, human, ChainError};
+use cargo::util::{CliResult, CargoResultExt, Config};
 
 #[derive(RustcDecodable)]
 pub struct Options {
@@ -51,8 +51,8 @@ pub fn execute(options: Options, config: &Config) -> CliResult {
             println!("please visit {}me and paste the API Token below", host);
             let mut line = String::new();
             let input = io::stdin();
-            input.lock().read_line(&mut line).chain_error(|| {
-                human("failed to read stdin")
+            input.lock().read_line(&mut line).chain_err(|| {
+                "failed to read stdin"
             })?;
             line
         }

src/bin/run.rs

@@ -2,7 +2,7 @@ use std::iter::FromIterator;
 
 use cargo::core::Workspace;
 use cargo::ops::{self, MessageFormat, Packages};
-use cargo::util::{CliResult, CliError, Config, Human};
+use cargo::util::{CliResult, CliError, Config, CargoErrorKind};
 use cargo::util::important_paths::{find_root_manifest_for_wd};
 
 #[derive(RustcDecodable)]
@@ -113,7 +113,8 @@ pub fn execute(options: Options, config: &Config) -> CliResult {
             // bad and we always want to forward that up.
             let exit = match err.exit.clone() {
                 Some(exit) => exit,
-                None => return Err(CliError::new(Box::new(Human(err)), 101)),
+                None => return Err(
+                    CliError::new(CargoErrorKind::ProcessErrorKind(err).into(), 101)),
             };
 
             // If `-q` was passed then we suppress extra error information about
@@ -123,7 +124,7 @@ pub fn execute(options: Options, config: &Config) -> CliResult {
             Err(if options.flag_quiet == Some(true) {
                 CliError::code(exit_code)
             } else {
-                CliError::new(Box::new(Human(err)), exit_code)
+                CliError::new(CargoErrorKind::ProcessErrorKind(err).into(), exit_code)
             })
         }
     }

src/bin/rustc.rs

@@ -3,7 +3,7 @@ use std::env;
 use cargo::core::Workspace;
 use cargo::ops::{self, CompileOptions, CompileMode, MessageFormat, Packages};
 use cargo::util::important_paths::{find_root_manifest_for_wd};
-use cargo::util::{CliResult, CliError, Config, human};
+use cargo::util::{CliResult, CliError, Config};
 
 #[derive(RustcDecodable)]
 pub struct Options {
@@ -98,8 +98,8 @@ pub fn execute(options: Options, config: &Config) -> CliResult {
         Some("bench") => CompileMode::Bench,
         Some("check") => CompileMode::Check,
         Some(mode) => {
-            let err = human(format!("unknown profile: `{}`, use dev,
-                                     test, or bench", mode));
+            let err = format!("unknown profile: `{}`, use dev,
+                                     test, or bench", mode).into();
             return Err(CliError::new(err, 101))
         }
     };

src/bin/test.rs

@@ -1,6 +1,6 @@
 use cargo::core::Workspace;
 use cargo::ops::{self, MessageFormat, Packages};
-use cargo::util::{CliResult, CliError, Human, human, Config};
+use cargo::util::{CliResult, CliError, Config, CargoErrorKind};
 use cargo::util::important_paths::find_root_manifest_for_wd;
 
 #[derive(RustcDecodable)]
@@ -163,8 +163,8 @@ pub fn execute(options: Options, config: &Config) -> CliResult {
         None => Ok(()),
         Some(err) => {
             Err(match err.exit.as_ref().and_then(|e| e.code()) {
-                Some(i) => CliError::new(human(err.hint()), i),
-                None => CliError::new(Box::new(Human(err)), 101),
+                Some(i) => CliError::new(err.hint().into(), i),
+                None => CliError::new(CargoErrorKind::CargoTestErrorKind(err).into(), 101),
             })
         }
     }

src/cargo/core/dependency.rs

@@ -7,7 +7,8 @@ use semver::ReqParseError;
 use serde::ser;
 
 use core::{SourceId, Summary, PackageId};
-use util::{CargoError, CargoResult, Cfg, CfgExpr, ChainError, human, Config};
+use util::{Cfg, CfgExpr, Config};
+use util::errors::{CargoResult, CargoResultExt, CargoError};
 
 /// Information about a dependency requested by a Cargo manifest.
 /// Cheap to copy.
@@ -145,7 +146,7 @@ this warning.
 
                         Ok(requirement)
                     }
-                    e => Err(From::from(e)),
+                    e => Err(e.into()),
                 }
             },
             Ok(v) => Ok(v),
@@ -361,13 +362,13 @@ impl ser::Serialize for Platform {
 }
 
 impl FromStr for Platform {
-    type Err = Box<CargoError>;
+    type Err = CargoError;
 
     fn from_str(s: &str) -> CargoResult<Platform> {
         if s.starts_with("cfg(") && s.ends_with(")") {
             let s = &s[4..s.len()-1];
-            s.parse().map(Platform::Cfg).chain_error(|| {
-                human(format!("failed to parse `{}` as a cfg expression", s))
+            s.parse().map(Platform::Cfg).chain_err(|| {
+                format!("failed to parse `{}` as a cfg expression", s)
             })
         } else {
             Ok(Platform::Name(s.to_string()))

src/cargo/core/package.rs

@@ -11,7 +11,8 @@ use toml;
 use core::{Dependency, Manifest, PackageId, SourceId, Target};
 use core::{Summary, SourceMap};
 use ops;
-use util::{CargoResult, Config, LazyCell, ChainError, internal, human, lev_distance};
+use util::{Config, LazyCell, internal, lev_distance};
+use util::errors::{CargoResult, CargoResultExt};
 
 /// Information about a package that is available somewhere in the file system.
 ///
@@ -181,19 +182,19 @@ impl<'cfg> PackageSet<'cfg> {
     }
 
     pub fn get(&self, id: &PackageId) -> CargoResult<&Package> {
-        let slot = self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
+        let slot = self.packages.iter().find(|p| p.0 == *id).ok_or_else(|| {
             internal(format!("couldn't find `{}` in package set", id))
         })?;
         let slot = &slot.1;
         if let Some(pkg) = slot.borrow() {
             return Ok(pkg)
         }
         let mut sources = self.sources.borrow_mut();
-        let source = sources.get_mut(id.source_id()).chain_error(|| {
+        let source = sources.get_mut(id.source_id()).ok_or_else(|| {
             internal(format!("couldn't find source for `{}`", id))
         })?;
-        let pkg = source.download(id).chain_error(|| {
-            human("unable to get packages from source")
+        let pkg = source.download(id).chain_err(|| {
+            "unable to get packages from source"
         })?;
         assert!(slot.fill(pkg).is_ok());
         Ok(slot.borrow().unwrap())