diff --git a/src/bin/cargo/commands/describe_future_incompatibilities.rs b/src/bin/cargo/commands/describe_future_incompatibilities.rs
index dd1b5f2b10b..79fd971857d 100644
--- a/src/bin/cargo/commands/describe_future_incompatibilities.rs
+++ b/src/bin/cargo/commands/describe_future_incompatibilities.rs
@@ -1,8 +1,7 @@
 use crate::command_prelude::*;
-use anyhow::anyhow;
+use anyhow::{anyhow, Context as _};
 use cargo::core::compiler::future_incompat::{OnDiskReport, FUTURE_INCOMPAT_FILE};
 use cargo::drop_eprint;
-use cargo::util::CargoResultExt;
 use std::io::Read;
 
 pub fn cli() -> App {
@@ -37,9 +36,9 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
     report_file
         .file()
         .read_to_string(&mut file_contents)
-        .chain_err(|| "failed to read report")?;
+        .with_context(|| "failed to read report")?;
     let on_disk_report: OnDiskReport =
-        serde_json::from_str(&file_contents).chain_err(|| "failed to load report")?;
+        serde_json::from_str(&file_contents).with_context(|| "failed to load report")?;
 
     let id = args.value_of("id").unwrap();
     if id != on_disk_report.id {
diff --git a/src/cargo/core/compiler/build_context/target_info.rs b/src/cargo/core/compiler/build_context/target_info.rs
index 44a46209b0e..8ab4af9b7d9 100644
--- a/src/cargo/core/compiler/build_context/target_info.rs
+++ b/src/cargo/core/compiler/build_context/target_info.rs
@@ -3,7 +3,8 @@ use crate::core::compiler::{
 };
 use crate::core::{Dependency, Target, TargetKind, Workspace};
 use crate::util::config::{Config, StringList, TargetConfig};
-use crate::util::{CargoResult, CargoResultExt, Rustc};
+use crate::util::{CargoResult, Rustc};
+use anyhow::Context as _;
 use cargo_platform::{Cfg, CfgExpr};
 use cargo_util::{paths, ProcessBuilder};
 use serde::{Deserialize, Serialize};
@@ -176,7 +177,7 @@ impl TargetInfo {
 
         let (output, error) = rustc
             .cached_output(&process, extra_fingerprint)
-            .chain_err(|| "failed to run `rustc` to learn about target-specific information")?;
+            .with_context(|| "failed to run `rustc` to learn about target-specific information")?;
 
         let mut lines = output.lines();
         let mut map = HashMap::new();
@@ -212,7 +213,7 @@ impl TargetInfo {
             .map(|line| Ok(Cfg::from_str(line)?))
             .filter(TargetInfo::not_user_specific_cfg)
             .collect::<CargoResult<Vec<_>>>()
-            .chain_err(|| {
+            .with_context(|| {
                 format!(
                     "failed to parse the cfg from `rustc --print=cfg`, got:\n{}",
                     output
@@ -413,7 +414,7 @@ impl TargetInfo {
 
         process.arg("--crate-type").arg(crate_type.as_str());
 
-        let output = process.exec_with_output().chain_err(|| {
+        let output = process.exec_with_output().with_context(|| {
             format!(
                 "failed to run `rustc` to learn about crate-type {} information",
                 crate_type
diff --git a/src/cargo/core/compiler/compile_kind.rs b/src/cargo/core/compiler/compile_kind.rs
index 41d5f64aac1..adfa55fce17 100644
--- a/src/cargo/core/compiler/compile_kind.rs
+++ b/src/cargo/core/compiler/compile_kind.rs
@@ -1,8 +1,8 @@
 use crate::core::Target;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{Config, StableHasher};
-use anyhow::bail;
+use anyhow::{bail, Context as _};
 use serde::Serialize;
 use std::collections::BTreeSet;
 use std::fs;
@@ -143,7 +143,7 @@ impl CompileTarget {
         // with different paths always produce the same result.
         let path = Path::new(name)
             .canonicalize()
-            .chain_err(|| anyhow::format_err!("target path {:?} is not a valid file", name))?;
+            .with_context(|| format!("target path {:?} is not a valid file", name))?;
 
         let name = path
             .into_os_string()
diff --git a/src/cargo/core/compiler/context/mod.rs b/src/cargo/core/compiler/context/mod.rs
index cb1dbb6240b..4502ba3c5f3 100644
--- a/src/cargo/core/compiler/context/mod.rs
+++ b/src/cargo/core/compiler/context/mod.rs
@@ -2,13 +2,14 @@ use std::collections::{BTreeSet, HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 
+use anyhow::Context as _;
 use filetime::FileTime;
 use jobserver::Client;
 
 use crate::core::compiler::compilation::{self, UnitOutput};
 use crate::core::compiler::{self, Unit};
 use crate::core::PackageId;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::profile;
 
 use super::build_plan::BuildPlan;
@@ -96,7 +97,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
             Some(c) => c.clone(),
             None => {
                 let client = Client::new(bcx.build_config.jobs as usize)
-                    .chain_err(|| "failed to create jobserver")?;
+                    .with_context(|| "failed to create jobserver")?;
                 client.acquire_raw()?;
                 client
             }
@@ -324,11 +325,11 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
         self.files_mut()
             .host
             .prepare()
-            .chain_err(|| "couldn't prepare build directories")?;
+            .with_context(|| "couldn't prepare build directories")?;
         for target in self.files.as_mut().unwrap().target.values_mut() {
             target
                 .prepare()
-                .chain_err(|| "couldn't prepare build directories")?;
+                .with_context(|| "couldn't prepare build directories")?;
         }
 
         let files = self.files.as_ref().unwrap();
@@ -559,11 +560,11 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
 
     pub fn new_jobserver(&mut self) -> CargoResult<Client> {
         let tokens = self.bcx.build_config.jobs as usize;
-        let client = Client::new(tokens).chain_err(|| "failed to create jobserver")?;
+        let client = Client::new(tokens).with_context(|| "failed to create jobserver")?;
 
         // Drain the client fully
         for i in 0..tokens {
-            client.acquire_raw().chain_err(|| {
+            client.acquire_raw().with_context(|| {
                 format!(
                     "failed to fully drain {}/{} token from jobserver at startup",
                     i, tokens,
diff --git a/src/cargo/core/compiler/custom_build.rs b/src/cargo/core/compiler/custom_build.rs
index dbf86e73a1b..a7a5ca1ba92 100644
--- a/src/cargo/core/compiler/custom_build.rs
+++ b/src/cargo/core/compiler/custom_build.rs
@@ -3,10 +3,11 @@ use super::{fingerprint, Context, LinkType, Unit};
 use crate::core::compiler::context::Metadata;
 use crate::core::compiler::job_queue::JobState;
 use crate::core::{profiles::ProfileRoot, PackageId};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::machine_message::{self, Message};
 use crate::util::{internal, profile};
+use anyhow::Context as _;
 use cargo_platform::Cfg;
 use cargo_util::paths;
 use std::collections::hash_map::{Entry, HashMap};
@@ -308,7 +309,7 @@ fn build_work(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Job> {
         // If we have an old build directory, then just move it into place,
         // otherwise create it!
         paths::create_dir_all(&script_out_dir)
-            .chain_err(|| "failed to create script output directory for build command")?;
+            .with_context(|| "failed to create script output directory for build command")?;
 
         // For all our native lib dependencies, pick up their metadata to pass
         // along to this custom build command. We're also careful to augment our
@@ -370,7 +371,7 @@ fn build_work(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Job> {
                 },
                 true,
             )
-            .chain_err(|| format!("failed to run custom build command for `{}`", pkg_descr));
+            .with_context(|| format!("failed to run custom build command for `{}`", pkg_descr));
 
         if let Err(error) = output {
             insert_warnings_in_build_outputs(
diff --git a/src/cargo/core/compiler/fingerprint.rs b/src/cargo/core/compiler/fingerprint.rs
index 4a9339bd992..afed819f98c 100644
--- a/src/cargo/core/compiler/fingerprint.rs
+++ b/src/cargo/core/compiler/fingerprint.rs
@@ -321,7 +321,7 @@ use std::str;
 use std::sync::{Arc, Mutex};
 use std::time::SystemTime;
 
-use anyhow::{bail, format_err};
+use anyhow::{bail, format_err, Context as _};
 use cargo_util::{paths, ProcessBuilder};
 use filetime::FileTime;
 use log::{debug, info};
@@ -332,7 +332,7 @@ use serde::{Deserialize, Serialize};
 use crate::core::compiler::unit_graph::UnitDep;
 use crate::core::Package;
 use crate::util;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{internal, path_args, profile};
 
@@ -1286,7 +1286,7 @@ fn calculate_normal(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Finger
     let target_root = target_root(cx);
     let local = if unit.mode.is_doc() {
         // rustdoc does not have dep-info files.
-        let fingerprint = pkg_fingerprint(cx.bcx, &unit.pkg).chain_err(|| {
+        let fingerprint = pkg_fingerprint(cx.bcx, &unit.pkg).with_context(|| {
             format!(
                 "failed to determine package fingerprint for documenting {}",
                 unit.pkg
@@ -1375,7 +1375,7 @@ fn calculate_run_custom_build(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoRes
     let local = (gen_local)(
         deps,
         Some(&|| {
-            pkg_fingerprint(cx.bcx, &unit.pkg).chain_err(|| {
+            pkg_fingerprint(cx.bcx, &unit.pkg).with_context(|| {
                 format!(
                     "failed to determine package fingerprint for build script for {}",
                     unit.pkg
@@ -1643,7 +1643,7 @@ fn compare_old_fingerprint(
 
     let old_fingerprint_json = paths::read(&loc.with_extension("json"))?;
     let old_fingerprint: Fingerprint = serde_json::from_str(&old_fingerprint_json)
-        .chain_err(|| internal("failed to deserialize json"))?;
+        .with_context(|| internal("failed to deserialize json"))?;
     // Fingerprint can be empty after a failed rebuild (see comment in prepare_target).
     if !old_fingerprint_short.is_empty() {
         debug_assert_eq!(util::to_hex(old_fingerprint.hash()), old_fingerprint_short);
diff --git a/src/cargo/core/compiler/job_queue.rs b/src/cargo/core/compiler/job_queue.rs
index 4491b1fd649..e67cfc1ce3e 100644
--- a/src/cargo/core/compiler/job_queue.rs
+++ b/src/cargo/core/compiler/job_queue.rs
@@ -56,7 +56,7 @@ use std::marker;
 use std::sync::Arc;
 use std::time::Duration;
 
-use anyhow::format_err;
+use anyhow::{format_err, Context as _};
 use cargo_util::ProcessBuilder;
 use crossbeam_utils::thread::Scope;
 use jobserver::{Acquired, Client, HelperThread};
@@ -78,8 +78,8 @@ use crate::core::{PackageId, Shell, TargetKind};
 use crate::drop_eprint;
 use crate::util::diagnostic_server::{self, DiagnosticPrinter};
 use crate::util::machine_message::{self, Message as _};
+use crate::util::CargoResult;
 use crate::util::{self, internal, profile};
-use crate::util::{CargoResult, CargoResultExt};
 use crate::util::{Config, DependencyQueue, Progress, ProgressStyle, Queue};
 
 /// This structure is backed by the `DependencyQueue` type and manages the
@@ -440,7 +440,7 @@ impl<'cfg> JobQueue<'cfg> {
             .into_helper_thread(move |token| {
                 messages.push(Message::Token(token));
             })
-            .chain_err(|| "failed to create helper thread for jobserver management")?;
+            .with_context(|| "failed to create helper thread for jobserver management")?;
 
         // Create a helper thread to manage the diagnostics for rustfix if
         // necessary.
@@ -537,7 +537,7 @@ impl<'cfg> DrainState<'cfg> {
                 .push(token);
             client
                 .release_raw()
-                .chain_err(|| "failed to release jobserver token")?;
+                .with_context(|| "failed to release jobserver token")?;
         }
 
         Ok(())
@@ -617,7 +617,7 @@ impl<'cfg> DrainState<'cfg> {
                     .push(FutureIncompatReportCrate { package_id, report });
             }
             Message::Token(acquired_token) => {
-                let token = acquired_token.chain_err(|| "failed to acquire jobserver token")?;
+                let token = acquired_token.with_context(|| "failed to acquire jobserver token")?;
                 self.tokens.push(token);
             }
             Message::NeedsToken(id) => {
diff --git a/src/cargo/core/compiler/mod.rs b/src/cargo/core/compiler/mod.rs
index a1dddf1ad82..ad43d1d9fa2 100644
--- a/src/cargo/core/compiler/mod.rs
+++ b/src/cargo/core/compiler/mod.rs
@@ -28,7 +28,7 @@ use std::io::{BufRead, Write};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
-use anyhow::Error;
+use anyhow::{Context as _, Error};
 use lazycell::LazyCell;
 use log::debug;
 
@@ -54,7 +54,7 @@ pub use crate::core::compiler::unit::{Unit, UnitInterner};
 use crate::core::manifest::TargetSourcePath;
 use crate::core::profiles::{PanicStrategy, Profile, Strip};
 use crate::core::{Feature, PackageId, Target};
-use crate::util::errors::{CargoResult, CargoResultExt, VerboseError};
+use crate::util::errors::{CargoResult, VerboseError};
 use crate::util::interning::InternedString;
 use crate::util::machine_message::{self, Message};
 use crate::util::{add_path_args, internal, iter_join_onto, profile};
@@ -331,7 +331,7 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
                 },
             )
             .map_err(verbose_if_simple_exit_code)
-            .chain_err(|| format!("could not compile `{}`", name))?;
+            .with_context(|| format!("could not compile `{}`", name))?;
         }
 
         if rustc_dep_info_loc.exists() {
@@ -345,7 +345,7 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
                 // Do not track source files in the fingerprint for registry dependencies.
                 is_local,
             )
-            .chain_err(|| {
+            .with_context(|| {
                 internal(format!(
                     "could not parse/generate dep info at: {}",
                     rustc_dep_info_loc.display()
@@ -665,7 +665,7 @@ fn rustdoc(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Work> {
                 },
                 false,
             )
-            .chain_err(|| format!("could not document `{}`", name))?;
+            .with_context(|| format!("could not document `{}`", name))?;
         Ok(())
     }))
 }
diff --git a/src/cargo/core/compiler/timings.rs b/src/cargo/core/compiler/timings.rs
index 182c078da74..836acac5cdb 100644
--- a/src/cargo/core/compiler/timings.rs
+++ b/src/cargo/core/compiler/timings.rs
@@ -8,7 +8,8 @@ use crate::core::compiler::BuildContext;
 use crate::core::PackageId;
 use crate::util::cpu::State;
 use crate::util::machine_message::{self, Message};
-use crate::util::{CargoResult, CargoResultExt, Config};
+use crate::util::{CargoResult, Config};
+use anyhow::Context as _;
 use cargo_util::paths;
 use std::collections::HashMap;
 use std::io::{BufWriter, Write};
@@ -324,7 +325,7 @@ impl<'cfg> Timings<'cfg> {
             .sort_unstable_by(|a, b| a.start.partial_cmp(&b.start).unwrap());
         if self.report_html {
             self.report_html(bcx, error)
-                .chain_err(|| "failed to save timing report")?;
+                .with_context(|| "failed to save timing report")?;
         }
         Ok(())
     }
diff --git a/src/cargo/core/dependency.rs b/src/cargo/core/dependency.rs
index 483ecef75bf..71bab190185 100644
--- a/src/cargo/core/dependency.rs
+++ b/src/cargo/core/dependency.rs
@@ -1,3 +1,4 @@
+use anyhow::Context as _;
 use cargo_platform::Platform;
 use log::trace;
 use semver::ReqParseError;
@@ -8,7 +9,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 
 use crate::core::{PackageId, SourceId, Summary};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::Config;
 
@@ -132,7 +133,7 @@ this warning.
         }
         Err(e) => {
             let err: CargoResult<VersionReq> = Err(e.into());
-            let v: VersionReq = err.chain_err(|| {
+            let v: VersionReq = err.with_context(|| {
                 format!(
                     "failed to parse the version requirement `{}` for dependency `{}`",
                     req, name
diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs
index 458ab128170..ec297fca61f 100644
--- a/src/cargo/core/manifest.rs
+++ b/src/cargo/core/manifest.rs
@@ -5,6 +5,7 @@ use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::Arc;
 
+use anyhow::Context as _;
 use semver::Version;
 use serde::ser;
 use serde::Serialize;
@@ -496,11 +497,9 @@ impl Manifest {
         if self.im_a_teapot.is_some() {
             self.unstable_features
                 .require(Feature::test_dummy_unstable())
-                .chain_err(|| {
-                    anyhow::format_err!(
-                        "the `im-a-teapot` manifest key is unstable and may \
-                         not work properly in England"
-                    )
+                .with_context(|| {
+                    "the `im-a-teapot` manifest key is unstable and may \
+                     not work properly in England"
                 })?;
         }
 
diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs
index 301c11c23ce..2400c78327f 100644
--- a/src/cargo/core/package.rs
+++ b/src/cargo/core/package.rs
@@ -26,7 +26,7 @@ use crate::core::{Dependency, Manifest, PackageId, SourceId, Target};
 use crate::core::{SourceMap, Summary, Workspace};
 use crate::ops;
 use crate::util::config::PackageCacheLock;
-use crate::util::errors::{CargoResult, CargoResultExt, HttpNot200};
+use crate::util::errors::{CargoResult, HttpNot200};
 use crate::util::interning::InternedString;
 use crate::util::network::Retry;
 use crate::util::{self, internal, Config, Progress, ProgressStyle};
@@ -416,7 +416,7 @@ impl<'cfg> PackageSet<'cfg> {
         let multiplexing = config.http_config()?.multiplexing.unwrap_or(true);
         multi
             .pipelining(false, multiplexing)
-            .chain_err(|| "failed to enable multiplexing/pipelining in curl")?;
+            .with_context(|| "failed to enable multiplexing/pipelining in curl")?;
 
         // let's not flood crates.io with connections
         multi.set_max_host_connections(2)?;
@@ -612,7 +612,7 @@ impl<'a, 'cfg> Downloads<'a, 'cfg> {
     /// the package is ready and doesn't need to be downloaded.
     pub fn start(&mut self, id: PackageId) -> CargoResult<Option<&'a Package>> {
         self.start_inner(id)
-            .chain_err(|| format!("failed to download `{}`", id))
+            .with_context(|| format!("failed to download `{}`", id))
     }
 
     fn start_inner(&mut self, id: PackageId) -> CargoResult<Option<&'a Package>> {
@@ -636,7 +636,7 @@ impl<'a, 'cfg> Downloads<'a, 'cfg> {
             .ok_or_else(|| internal(format!("couldn't find source for `{}`", id)))?;
         let pkg = source
             .download(id)
-            .chain_err(|| anyhow::format_err!("unable to get packages from source"))?;
+            .with_context(|| "unable to get packages from source")?;
         let (url, descriptor) = match pkg {
             MaybePackage::Ready(pkg) => {
                 debug!("{} doesn't need a download", id);
@@ -810,7 +810,7 @@ impl<'a, 'cfg> Downloads<'a, 'cfg> {
                         }
                         Ok(())
                     })
-                    .chain_err(|| format!("failed to download from `{}`", dl.url))?
+                    .with_context(|| format!("failed to download from `{}`", dl.url))?
             };
             match ret {
                 Some(()) => break (dl, data),
@@ -908,7 +908,7 @@ impl<'a, 'cfg> Downloads<'a, 'cfg> {
                 self.set
                     .multi
                     .perform()
-                    .chain_err(|| "failed to perform http requests")
+                    .with_context(|| "failed to perform http requests")
             })?;
             debug!("handles remaining: {}", n);
             let results = &mut self.results;
@@ -935,7 +935,7 @@ impl<'a, 'cfg> Downloads<'a, 'cfg> {
             self.set
                 .multi
                 .wait(&mut [], timeout)
-                .chain_err(|| "failed to wait on curl `Multi`")?;
+                .with_context(|| "failed to wait on curl `Multi`")?;
         }
     }
 
diff --git a/src/cargo/core/package_id_spec.rs b/src/cargo/core/package_id_spec.rs
index 6049e981fa9..723b624e8bf 100644
--- a/src/cargo/core/package_id_spec.rs
+++ b/src/cargo/core/package_id_spec.rs
@@ -1,13 +1,13 @@
 use std::collections::HashMap;
 use std::fmt;
 
-use anyhow::bail;
+use anyhow::{bail, Context as _};
 use semver::Version;
 use serde::{de, ser};
 use url::Url;
 
 use crate::core::PackageId;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::lev_distance;
 use crate::util::{validate_package_name, IntoUrl, ToSemver};
@@ -85,9 +85,9 @@ impl PackageIdSpec {
         I: IntoIterator<Item = PackageId>,
     {
         let i: Vec<_> = i.into_iter().collect();
-        let spec = PackageIdSpec::parse(spec).chain_err(|| {
+        let spec = PackageIdSpec::parse(spec).with_context(|| {
             let suggestion = lev_distance::closest_msg(spec, i.iter(), |id| id.name().as_str());
-            anyhow::format_err!("invalid package ID specification: `{}`{}", spec, suggestion)
+            format!("invalid package ID specification: `{}`{}", spec, suggestion)
         })?;
         spec.query(i)
     }
diff --git a/src/cargo/core/profiles.rs b/src/cargo/core/profiles.rs
index d1baaa24442..a86f0899e58 100644
--- a/src/cargo/core/profiles.rs
+++ b/src/cargo/core/profiles.rs
@@ -1,11 +1,10 @@
 use crate::core::compiler::{CompileKind, CompileMode, Unit};
 use crate::core::resolver::features::FeaturesFor;
 use crate::core::{Feature, PackageId, PackageIdSpec, Resolve, Shell, Target, Workspace};
-use crate::util::errors::CargoResultExt;
 use crate::util::interning::InternedString;
 use crate::util::toml::{ProfilePackageSpec, StringOrBool, TomlProfile, TomlProfiles, U32OrBool};
 use crate::util::{closest_msg, config, CargoResult, Config};
-use anyhow::bail;
+use anyhow::{bail, Context as _};
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::hash::Hash;
 use std::{cmp, env, fmt, hash};
@@ -1142,11 +1141,10 @@ fn get_config_profile(ws: &Workspace<'_>, name: &str) -> CargoResult<Option<Toml
     profile
         .val
         .validate(name, ws.unstable_features(), &mut warnings)
-        .chain_err(|| {
-            anyhow::format_err!(
+        .with_context(|| {
+            format!(
                 "config profile `{}` is not valid (defined in `{}`)",
-                name,
-                profile.definition
+                name, profile.definition
             )
         })?;
     for warning in warnings {
diff --git a/src/cargo/core/registry.rs b/src/cargo/core/registry.rs
index 0380c447d39..35ddee7b8b2 100644
--- a/src/cargo/core/registry.rs
+++ b/src/cargo/core/registry.rs
@@ -3,10 +3,10 @@ use std::collections::{HashMap, HashSet};
 use crate::core::PackageSet;
 use crate::core::{Dependency, PackageId, Source, SourceId, SourceMap, Summary};
 use crate::sources::config::SourceConfigMap;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{profile, CanonicalUrl, Config};
-use anyhow::bail;
+use anyhow::{bail, Context as _};
 use log::{debug, trace};
 use semver::VersionReq;
 use url::Url;
@@ -281,8 +281,8 @@ impl<'cfg> PackageRegistry<'cfg> {
                 // normally would and then ask it directly for the list of summaries
                 // corresponding to this `dep`.
                 self.ensure_loaded(dep.source_id(), Kind::Normal)
-                    .chain_err(|| {
-                        anyhow::format_err!(
+                    .with_context(|| {
+                        format!(
                             "failed to load source for dependency `{}`",
                             dep.package_name()
                         )
@@ -293,14 +293,16 @@ impl<'cfg> PackageRegistry<'cfg> {
                     .get_mut(dep.source_id())
                     .expect("loaded source not present");
                 let summaries = source.query_vec(dep)?;
-                let (summary, should_unlock) =
-                    summary_for_patch(orig_patch, locked, summaries, source).chain_err(|| {
-                        format!(
-                            "patch for `{}` in `{}` failed to resolve",
-                            orig_patch.package_name(),
-                            url,
-                        )
-                    })?;
+                let (summary, should_unlock) = summary_for_patch(
+                    orig_patch, locked, summaries, source,
+                )
+                .with_context(|| {
+                    format!(
+                        "patch for `{}` in `{}` failed to resolve",
+                        orig_patch.package_name(),
+                        url,
+                    )
+                })?;
                 debug!(
                     "patch summary is {:?} should_unlock={:?}",
                     summary, should_unlock
@@ -320,7 +322,7 @@ impl<'cfg> PackageRegistry<'cfg> {
                 Ok(summary)
             })
             .collect::<CargoResult<Vec<_>>>()
-            .chain_err(|| anyhow::format_err!("failed to resolve patches for `{}`", url))?;
+            .with_context(|| format!("failed to resolve patches for `{}`", url))?;
 
         let mut name_and_version = HashSet::new();
         for summary in unlocked_summaries.iter() {
@@ -388,7 +390,7 @@ impl<'cfg> PackageRegistry<'cfg> {
             let _p = profile::start(format!("updating: {}", source_id));
             self.sources.get_mut(source_id).unwrap().update()
         })()
-        .chain_err(|| anyhow::format_err!("Unable to update {}", source_id))?;
+        .with_context(|| format!("Unable to update {}", source_id))?;
         Ok(())
     }
 
@@ -539,8 +541,8 @@ impl<'cfg> Registry for PackageRegistry<'cfg> {
 
                 // Ensure the requested source_id is loaded
                 self.ensure_loaded(dep.source_id(), Kind::Normal)
-                    .chain_err(|| {
-                        anyhow::format_err!(
+                    .with_context(|| {
+                        format!(
                             "failed to load source for dependency `{}`",
                             dep.package_name()
                         )
diff --git a/src/cargo/core/resolver/dep_cache.rs b/src/cargo/core/resolver/dep_cache.rs
index 063626639a2..91afa13f709 100644
--- a/src/cargo/core/resolver/dep_cache.rs
+++ b/src/cargo/core/resolver/dep_cache.rs
@@ -16,8 +16,10 @@ use crate::core::resolver::{
     ActivateError, ActivateResult, CliFeatures, RequestedFeatures, ResolveOpts,
 };
 use crate::core::{Dependency, FeatureValue, PackageId, PackageIdSpec, Registry, Summary};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
+
+use anyhow::Context as _;
 use log::debug;
 use std::cmp::Ordering;
 use std::collections::{BTreeSet, HashMap, HashSet};
@@ -222,8 +224,8 @@ impl<'a> RegistryQueryer<'a> {
         let mut deps = deps
             .into_iter()
             .map(|(dep, features)| {
-                let candidates = self.query(&dep).chain_err(|| {
-                    anyhow::format_err!(
+                let candidates = self.query(&dep).with_context(|| {
+                    format!(
                         "failed to get `{}` as a dependency of {}",
                         dep.package_name(),
                         describe_path(&cx.parents.path_to_bottom(&candidate.package_id())),
diff --git a/src/cargo/core/resolver/encode.rs b/src/cargo/core/resolver/encode.rs
index 9b93a744980..19de1049ded 100644
--- a/src/cargo/core/resolver/encode.rs
+++ b/src/cargo/core/resolver/encode.rs
@@ -113,10 +113,10 @@
 
 use super::{Resolve, ResolveVersion};
 use crate::core::{Dependency, GitReference, Package, PackageId, SourceId, Workspace};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{internal, Graph};
-use anyhow::bail;
+use anyhow::{bail, Context as _};
 use log::debug;
 use serde::de;
 use serde::ser;
@@ -333,7 +333,7 @@ impl EncodableResolve {
             let k = &k[prefix.len()..];
             let enc_id: EncodablePackageId = k
                 .parse()
-                .chain_err(|| internal("invalid encoding of checksum in lockfile"))?;
+                .with_context(|| internal("invalid encoding of checksum in lockfile"))?;
             let id = match lookup_id(&enc_id) {
                 Some(id) => id,
                 _ => continue,
diff --git a/src/cargo/core/workspace.rs b/src/cargo/core/workspace.rs
index fc5608c1ae8..d00c5e47e1c 100644
--- a/src/cargo/core/workspace.rs
+++ b/src/cargo/core/workspace.rs
@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::slice;
 
-use anyhow::bail;
+use anyhow::{bail, Context as _};
 use glob::glob;
 use log::debug;
 use url::Url;
@@ -18,7 +18,7 @@ use crate::core::{Dependency, Edition, FeatureValue, PackageId, PackageIdSpec};
 use crate::core::{EitherManifest, Package, SourceId, VirtualManifest};
 use crate::ops;
 use crate::sources::{PathSource, CRATES_IO_INDEX, CRATES_IO_REGISTRY};
-use crate::util::errors::{CargoResult, CargoResultExt, ManifestError};
+use crate::util::errors::{CargoResult, ManifestError};
 use crate::util::interning::InternedString;
 use crate::util::toml::{read_manifest, TomlDependency, TomlProfiles};
 use crate::util::{config::ConfigRelativePath, Config, Filesystem, IntoUrl};
@@ -386,7 +386,7 @@ impl<'cfg> Workspace<'cfg> {
                     .config
                     .get_registry_index(url)
                     .or_else(|_| url.into_url())
-                    .chain_err(|| {
+                    .with_context(|| {
                         format!("[patch] entry `{}` should be a URL or registry name", url)
                     })?,
             };
@@ -1415,12 +1415,9 @@ impl WorkspaceRootConfig {
             Some(p) => p,
             None => return Ok(Vec::new()),
         };
-        let res =
-            glob(path).chain_err(|| anyhow::format_err!("could not parse pattern `{}`", &path))?;
+        let res = glob(path).with_context(|| format!("could not parse pattern `{}`", &path))?;
         let res = res
-            .map(|p| {
-                p.chain_err(|| anyhow::format_err!("unable to match path to pattern `{}`", &path))
-            })
+            .map(|p| p.with_context(|| format!("unable to match path to pattern `{}`", &path)))
             .collect::<Result<Vec<_>, _>>()?;
         Ok(res)
     }
diff --git a/src/cargo/ops/cargo_clean.rs b/src/cargo/ops/cargo_clean.rs
index ad2171e827b..76b6927519a 100644
--- a/src/cargo/ops/cargo_clean.rs
+++ b/src/cargo/ops/cargo_clean.rs
@@ -2,10 +2,12 @@ use crate::core::compiler::{CompileKind, CompileMode, Layout, RustcTargetData};
 use crate::core::profiles::Profiles;
 use crate::core::{PackageIdSpec, TargetKind, Workspace};
 use crate::ops;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::lev_distance;
 use crate::util::Config;
+
+use anyhow::Context as _;
 use cargo_util::paths;
 use std::fs;
 use std::path::Path;
@@ -222,14 +224,12 @@ fn rm_rf(path: &Path, config: &Config) -> CargoResult<()> {
         config
             .shell()
             .verbose(|shell| shell.status("Removing", path.display()))?;
-        paths::remove_dir_all(path)
-            .chain_err(|| anyhow::format_err!("could not remove build directory"))?;
+        paths::remove_dir_all(path).with_context(|| "could not remove build directory")?;
     } else if m.is_ok() {
         config
             .shell()
             .verbose(|shell| shell.status("Removing", path.display()))?;
-        paths::remove_file(path)
-            .chain_err(|| anyhow::format_err!("failed to remove build artifact"))?;
+        paths::remove_file(path).with_context(|| "failed to remove build artifact")?;
     }
     Ok(())
 }
diff --git a/src/cargo/ops/cargo_install.rs b/src/cargo/ops/cargo_install.rs
index 93276fa51b7..1df7e56f532 100644
--- a/src/cargo/ops/cargo_install.rs
+++ b/src/cargo/ops/cargo_install.rs
@@ -7,10 +7,11 @@ use crate::core::compiler::{CompileKind, DefaultExecutor, Executor, Freshness, U
 use crate::core::{Dependency, Edition, Package, PackageId, Source, SourceId, Workspace};
 use crate::ops::common_for_install_and_uninstall::*;
 use crate::sources::{GitSource, PathSource, SourceConfigMap};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::{Config, Filesystem, Rustc, ToSemver};
 use crate::{drop_println, ops};
-use anyhow::{bail, format_err};
+
+use anyhow::{bail, format_err, Context as _};
 use cargo_util::paths;
 use semver::VersionReq;
 use tempfile::Builder as TempFileBuilder;
@@ -350,13 +351,13 @@ fn install_one(
     check_yanked_install(&ws)?;
 
     let exec: Arc<dyn Executor> = Arc::new(DefaultExecutor);
-    let compile = ops::compile_ws(&ws, opts, &exec).chain_err(|| {
+    let compile = ops::compile_ws(&ws, opts, &exec).with_context(|| {
         if let Some(td) = td_opt.take() {
             // preserve the temporary directory, so the user can inspect it
             td.into_path();
         }
 
-        format_err!(
+        format!(
             "failed to compile `{}`, intermediate artifacts can be \
              found at `{}`",
             pkg,
@@ -420,8 +421,8 @@ fn install_one(
         let src = staging_dir.path().join(bin);
         let dst = dst.join(bin);
         config.shell().status("Installing", dst.display())?;
-        fs::rename(&src, &dst).chain_err(|| {
-            format_err!("failed to move `{}` to `{}`", src.display(), dst.display())
+        fs::rename(&src, &dst).with_context(|| {
+            format!("failed to move `{}` to `{}`", src.display(), dst.display())
         })?;
         installed.bins.push(dst);
         successful_bins.insert(bin.to_string());
@@ -435,8 +436,8 @@ fn install_one(
                 let src = staging_dir.path().join(bin);
                 let dst = dst.join(bin);
                 config.shell().status("Replacing", dst.display())?;
-                fs::rename(&src, &dst).chain_err(|| {
-                    format_err!("failed to move `{}` to `{}`", src.display(), dst.display())
+                fs::rename(&src, &dst).with_context(|| {
+                    format!("failed to move `{}` to `{}`", src.display(), dst.display())
                 })?;
                 successful_bins.insert(bin.to_string());
             }
@@ -463,7 +464,7 @@ fn install_one(
         }
 
         match tracker.save() {
-            Err(err) => replace_result.chain_err(|| err)?,
+            Err(err) => replace_result.with_context(|| err)?,
             Ok(_) => replace_result?,
         }
     }
@@ -736,7 +737,7 @@ fn remove_orphaned_bins(
                     ),
                 )?;
                 paths::remove_file(&full_path)
-                    .chain_err(|| format!("failed to remove {:?}", full_path))?;
+                    .with_context(|| format!("failed to remove {:?}", full_path))?;
             }
         }
     }
diff --git a/src/cargo/ops/cargo_new.rs b/src/cargo/ops/cargo_new.rs
index c25c016c056..64b1d3620af 100644
--- a/src/cargo/ops/cargo_new.rs
+++ b/src/cargo/ops/cargo_new.rs
@@ -1,7 +1,8 @@
 use crate::core::{Edition, Shell, Workspace};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::{existing_vcs_repo, FossilRepo, GitRepo, HgRepo, PijulRepo};
 use crate::util::{restricted_names, Config};
+use anyhow::Context as _;
 use cargo_util::paths;
 use serde::de;
 use serde::Deserialize;
@@ -416,8 +417,8 @@ pub fn new(opts: &NewOptions, config: &Config) -> CargoResult<()> {
         registry: opts.registry.as_deref(),
     };
 
-    mk(config, &mkopts).chain_err(|| {
-        anyhow::format_err!(
+    mk(config, &mkopts).with_context(|| {
+        format!(
             "Failed to create package `{}` at `{}`",
             name,
             path.display()
@@ -500,8 +501,8 @@ pub fn init(opts: &NewOptions, config: &Config) -> CargoResult<()> {
         registry: opts.registry.as_deref(),
     };
 
-    mk(config, &mkopts).chain_err(|| {
-        anyhow::format_err!(
+    mk(config, &mkopts).with_context(|| {
+        format!(
             "Failed to create package `{}` at `{}`",
             name,
             path.display()
diff --git a/src/cargo/ops/cargo_package.rs b/src/cargo/ops/cargo_package.rs
index fd37e2c730e..1056d73fdaa 100644
--- a/src/cargo/ops/cargo_package.rs
+++ b/src/cargo/ops/cargo_package.rs
@@ -11,10 +11,11 @@ use crate::core::resolver::CliFeatures;
 use crate::core::{Feature, Shell, Verbosity, Workspace};
 use crate::core::{Package, PackageId, PackageSet, Resolve, Source, SourceId};
 use crate::sources::PathSource;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::toml::TomlManifest;
 use crate::util::{self, restricted_names, Config, FileLock};
 use crate::{drop_println, ops};
+use anyhow::Context as _;
 use cargo_util::paths;
 use flate2::read::GzDecoder;
 use flate2::{Compression, GzBuilder};
@@ -122,17 +123,17 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Option
         .status("Packaging", pkg.package_id().to_string())?;
     dst.file().set_len(0)?;
     tar(ws, ar_files, dst.file(), &filename)
-        .chain_err(|| anyhow::format_err!("failed to prepare local package for uploading"))?;
+        .with_context(|| "failed to prepare local package for uploading")?;
     if opts.verify {
         dst.seek(SeekFrom::Start(0))?;
-        run_verify(ws, &dst, opts).chain_err(|| "failed to verify package tarball")?
+        run_verify(ws, &dst, opts).with_context(|| "failed to verify package tarball")?
     }
     dst.seek(SeekFrom::Start(0))?;
     {
         let src_path = dst.path();
         let dst_path = dst.parent().join(&filename);
         fs::rename(&src_path, &dst_path)
-            .chain_err(|| "failed to move temporary tarball into final location")?;
+            .with_context(|| "failed to move temporary tarball into final location")?;
     }
     Ok(Some(dst))
 }
@@ -501,16 +502,16 @@ fn tar(
         let mut header = Header::new_gnu();
         match contents {
             FileContents::OnDisk(disk_path) => {
-                let mut file = File::open(&disk_path).chain_err(|| {
+                let mut file = File::open(&disk_path).with_context(|| {
                     format!("failed to open for archiving: `{}`", disk_path.display())
                 })?;
-                let metadata = file.metadata().chain_err(|| {
+                let metadata = file.metadata().with_context(|| {
                     format!("could not learn metadata for: `{}`", disk_path.display())
                 })?;
                 header.set_metadata_in_mode(&metadata, HeaderMode::Deterministic);
                 header.set_cksum();
                 ar.append_data(&mut header, &ar_path, &mut file)
-                    .chain_err(|| {
+                    .with_context(|| {
                         format!("could not archive source file `{}`", disk_path.display())
                     })?;
             }
@@ -525,7 +526,7 @@ fn tar(
                 header.set_size(contents.len() as u64);
                 header.set_cksum();
                 ar.append_data(&mut header, &ar_path, contents.as_bytes())
-                    .chain_err(|| format!("could not archive source file `{}`", rel_str))?;
+                    .with_context(|| format!("could not archive source file `{}`", rel_str))?;
             }
         }
     }
@@ -739,7 +740,7 @@ fn hash_all(path: &Path) -> CargoResult<HashMap<PathBuf, u64>> {
         }
         Ok(result)
     }
-    let result = wrap(path).chain_err(|| format!("failed to verify output at {:?}", path))?;
+    let result = wrap(path).with_context(|| format!("failed to verify output at {:?}", path))?;
     Ok(result)
 }
 
diff --git a/src/cargo/ops/common_for_install_and_uninstall.rs b/src/cargo/ops/common_for_install_and_uninstall.rs
index dca44739d45..b6f53a83f64 100644
--- a/src/cargo/ops/common_for_install_and_uninstall.rs
+++ b/src/cargo/ops/common_for_install_and_uninstall.rs
@@ -5,14 +5,14 @@ use std::io::SeekFrom;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 
-use anyhow::{bail, format_err};
+use anyhow::{bail, format_err, Context as _};
 use serde::{Deserialize, Serialize};
 
 use crate::core::compiler::Freshness;
 use crate::core::{Dependency, FeatureValue, Package, PackageId, Source, SourceId};
 use crate::ops::{self, CompileFilter, CompileOptions};
 use crate::sources::PathSource;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::Config;
 use crate::util::{FileLock, Filesystem};
 
@@ -101,12 +101,11 @@ impl InstallTracker {
             if contents.is_empty() {
                 Ok(CrateListingV1::default())
             } else {
-                Ok(toml::from_str(&contents)
-                    .chain_err(|| format_err!("invalid TOML found for metadata"))?)
+                Ok(toml::from_str(&contents).with_context(|| "invalid TOML found for metadata")?)
             }
         })()
-        .chain_err(|| {
-            format_err!(
+        .with_context(|| {
+            format!(
                 "failed to parse crate metadata at `{}`",
                 v1_lock.path().to_string_lossy()
             )
@@ -119,13 +118,13 @@ impl InstallTracker {
                 CrateListingV2::default()
             } else {
                 serde_json::from_str(&contents)
-                    .chain_err(|| format_err!("invalid JSON found for metadata"))?
+                    .with_context(|| "invalid JSON found for metadata")?
             };
             v2.sync_v1(&v1);
             Ok(v2)
         })()
-        .chain_err(|| {
-            format_err!(
+        .with_context(|| {
+            format!(
                 "failed to parse crate metadata at `{}`",
                 v2_lock.path().to_string_lossy()
             )
@@ -278,15 +277,15 @@ impl InstallTracker {
 
     /// Save tracking information to disk.
     pub fn save(&self) -> CargoResult<()> {
-        self.v1.save(&self.v1_lock).chain_err(|| {
-            format_err!(
+        self.v1.save(&self.v1_lock).with_context(|| {
+            format!(
                 "failed to write crate metadata at `{}`",
                 self.v1_lock.path().to_string_lossy()
             )
         })?;
 
-        self.v2.save(&self.v2_lock).chain_err(|| {
-            format_err!(
+        self.v2.save(&self.v2_lock).with_context(|| {
+            format!(
                 "failed to write crate metadata at `{}`",
                 self.v2_lock.path().to_string_lossy()
             )
diff --git a/src/cargo/ops/lockfile.rs b/src/cargo/ops/lockfile.rs
index 7fca8d87279..45b814740ae 100644
--- a/src/cargo/ops/lockfile.rs
+++ b/src/cargo/ops/lockfile.rs
@@ -1,10 +1,12 @@
 use std::io::prelude::*;
 
 use crate::core::{resolver, Resolve, ResolveVersion, Workspace};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::toml as cargo_toml;
 use crate::util::Filesystem;
 
+use anyhow::Context as _;
+
 pub fn load_pkg_lockfile(ws: &Workspace<'_>) -> CargoResult<Option<Resolve>> {
     if !ws.root().join("Cargo.lock").exists() {
         return Ok(None);
@@ -15,14 +17,14 @@ pub fn load_pkg_lockfile(ws: &Workspace<'_>) -> CargoResult<Option<Resolve>> {
 
     let mut s = String::new();
     f.read_to_string(&mut s)
-        .chain_err(|| format!("failed to read file: {}", f.path().display()))?;
+        .with_context(|| format!("failed to read file: {}", f.path().display()))?;
 
     let 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(&s, ws)?))
     })()
-    .chain_err(|| format!("failed to parse lock file at: {}", f.path().display()))?;
+    .with_context(|| format!("failed to parse lock file at: {}", f.path().display()))?;
     Ok(resolve)
 }
 
@@ -80,7 +82,7 @@ pub fn write_pkg_lockfile(ws: &Workspace<'_>, resolve: &mut Resolve) -> CargoRes
             f.write_all(out.as_bytes())?;
             Ok(())
         })
-        .chain_err(|| format!("failed to write {}", ws.root().join("Cargo.lock").display()))?;
+        .with_context(|| format!("failed to write {}", ws.root().join("Cargo.lock").display()))?;
     Ok(())
 }
 
diff --git a/src/cargo/ops/registry.rs b/src/cargo/ops/registry.rs
index 796623db2aa..8797198fd49 100644
--- a/src/cargo/ops/registry.rs
+++ b/src/cargo/ops/registry.rs
@@ -7,7 +7,7 @@ use std::str;
 use std::time::Duration;
 use std::{cmp, env};
 
-use anyhow::{bail, format_err};
+use anyhow::{bail, format_err, Context as _};
 use cargo_util::paths;
 use crates_io::{self, NewCrate, NewCrateDependency, Registry};
 use curl::easy::{Easy, InfoType, SslOpt, SslVersion};
@@ -22,7 +22,7 @@ use crate::core::{Package, SourceId, Workspace};
 use crate::ops;
 use crate::sources::{RegistrySource, SourceConfigMap, CRATES_IO_REGISTRY};
 use crate::util::config::{self, Config, SslVersionConfig, SslVersionConfigRange};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::important_paths::find_root_manifest_for_wd;
 use crate::util::validate_package_name;
 use crate::util::IntoUrl;
@@ -256,7 +256,7 @@ fn transmit(
         .as_ref()
         .map(|readme| {
             paths::read(&pkg.root().join(readme))
-                .chain_err(|| format!("failed to read `readme` file for package `{}`", pkg))
+                .with_context(|| format!("failed to read `readme` file for package `{}`", pkg))
         })
         .transpose()?;
     if let Some(ref file) = *license_file {
@@ -308,7 +308,7 @@ fn transmit(
             },
             tarball,
         )
-        .chain_err(|| format!("failed to publish to registry at {}", registry.host()))?;
+        .with_context(|| format!("failed to publish to registry at {}", registry.host()))?;
 
     if !warnings.invalid_categories.is_empty() {
         let msg = format!(
@@ -452,7 +452,7 @@ fn registry(
         let cfg = src.config();
         let mut updated_cfg = || {
             src.update()
-                .chain_err(|| format!("failed to update {}", sid))?;
+                .with_context(|| format!("failed to update {}", sid))?;
             src.config()
         };
 
@@ -726,7 +726,7 @@ pub fn registry_login(
             input
                 .lock()
                 .read_line(&mut line)
-                .chain_err(|| "failed to read stdin")?;
+                .with_context(|| "failed to read stdin")?;
             // Automatically remove `cargo login` from an inputted token to
             // allow direct pastes from `registry.host()`/me.
             line.replace("cargo login", "").trim().to_string()
@@ -815,7 +815,7 @@ pub fn modify_owners(config: &Config, opts: &OwnersOptions) -> CargoResult<()> {
 
     if let Some(ref v) = opts.to_add {
         let v = v.iter().map(|s| &s[..]).collect::<Vec<_>>();
-        let msg = registry.add_owners(&name, &v).chain_err(|| {
+        let msg = registry.add_owners(&name, &v).with_context(|| {
             format!(
                 "failed to invite owners to crate `{}` on registry at {}",
                 name,
@@ -831,7 +831,7 @@ pub fn modify_owners(config: &Config, opts: &OwnersOptions) -> CargoResult<()> {
         config
             .shell()
             .status("Owner", format!("removing {:?} from crate {}", v, name))?;
-        registry.remove_owners(&name, &v).chain_err(|| {
+        registry.remove_owners(&name, &v).with_context(|| {
             format!(
                 "failed to remove owners from crate `{}` on registry at {}",
                 name,
@@ -841,7 +841,7 @@ pub fn modify_owners(config: &Config, opts: &OwnersOptions) -> CargoResult<()> {
     }
 
     if opts.list {
-        let owners = registry.list_owners(&name).chain_err(|| {
+        let owners = registry.list_owners(&name).with_context(|| {
             format!(
                 "failed to list owners of crate `{}` on registry at {}",
                 name,
@@ -889,7 +889,7 @@ pub fn yank(
         config
             .shell()
             .status("Unyank", format!("{}:{}", name, version))?;
-        registry.unyank(&name, &version).chain_err(|| {
+        registry.unyank(&name, &version).with_context(|| {
             format!(
                 "failed to undo a yank from the registry at {}",
                 registry.host()
@@ -901,7 +901,7 @@ pub fn yank(
             .status("Yank", format!("{}:{}", name, version))?;
         registry
             .yank(&name, &version)
-            .chain_err(|| format!("failed to yank from the registry at {}", registry.host()))?;
+            .with_context(|| format!("failed to yank from the registry at {}", registry.host()))?;
     }
 
     Ok(())
@@ -947,7 +947,7 @@ pub fn search(
     }
 
     let (mut registry, _, source_id) = registry(config, None, index, reg, false, false)?;
-    let (crates, total_crates) = registry.search(query, limit).chain_err(|| {
+    let (crates, total_crates) = registry.search(query, limit).with_context(|| {
         format!(
             "failed to retrieve search results from the registry at {}",
             registry.host()
diff --git a/src/cargo/ops/registry/auth.rs b/src/cargo/ops/registry/auth.rs
index b76a08fc7c5..d10b1988e92 100644
--- a/src/cargo/ops/registry/auth.rs
+++ b/src/cargo/ops/registry/auth.rs
@@ -1,9 +1,8 @@
 //! Registry authentication support.
 
 use crate::sources::CRATES_IO_REGISTRY;
-use crate::util::{config, CargoResult, CargoResultExt, Config};
-use anyhow::bail;
-use anyhow::format_err;
+use crate::util::{config, CargoResult, Config};
+use anyhow::{bail, format_err, Context as _};
 use cargo_util::ProcessError;
 use std::io::{Read, Write};
 use std::path::PathBuf;
@@ -135,7 +134,7 @@ fn run_command(
         }
         Action::Erase => {}
     }
-    let mut child = cmd.spawn().chain_err(|| {
+    let mut child = cmd.spawn().with_context(|| {
         let verb = match action {
             Action::Get => "fetch",
             Action::Store(_) => "store",
@@ -158,7 +157,7 @@ fn run_command(
                 .as_mut()
                 .unwrap()
                 .read_to_string(&mut buffer)
-                .chain_err(|| {
+                .with_context(|| {
                     format!(
                         "failed to read token from registry credential process `{}`",
                         exe.display()
@@ -177,7 +176,7 @@ fn run_command(
             token = Some(buffer);
         }
         Action::Store(token) => {
-            writeln!(child.stdin.as_ref().unwrap(), "{}", token).chain_err(|| {
+            writeln!(child.stdin.as_ref().unwrap(), "{}", token).with_context(|| {
                 format!(
                     "failed to send token to registry credential process `{}`",
                     exe.display()
@@ -186,7 +185,7 @@ fn run_command(
         }
         Action::Erase => {}
     }
-    let status = child.wait().chain_err(|| {
+    let status = child.wait().with_context(|| {
         format!(
             "registry credential process `{}` exit failure",
             exe.display()
diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs
index 617421a72f5..e122f4e6778 100644
--- a/src/cargo/ops/resolve.rs
+++ b/src/cargo/ops/resolve.rs
@@ -23,8 +23,9 @@ use crate::core::{
 };
 use crate::ops;
 use crate::sources::PathSource;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::{profile, CanonicalUrl};
+use anyhow::Context as _;
 use log::{debug, trace};
 use std::collections::HashSet;
 
@@ -412,7 +413,7 @@ pub fn add_overrides<'a>(
     for (path, definition) in paths {
         let id = SourceId::for_path(&path)?;
         let mut source = PathSource::new_recursive(&path, id, ws.config());
-        source.update().chain_err(|| {
+        source.update().with_context(|| {
             format!(
                 "failed to update path override `{}` \
                  (defined in `{}`)",
diff --git a/src/cargo/ops/vendor.rs b/src/cargo/ops/vendor.rs
index cae24d471c6..0048271528b 100644
--- a/src/cargo/ops/vendor.rs
+++ b/src/cargo/ops/vendor.rs
@@ -2,8 +2,8 @@ use crate::core::shell::Verbosity;
 use crate::core::{GitReference, Workspace};
 use crate::ops;
 use crate::sources::path::PathSource;
-use crate::util::{CargoResult, CargoResultExt, Config};
-use anyhow::bail;
+use crate::util::{CargoResult, Config};
+use anyhow::{bail, Context as _};
 use cargo_util::{paths, Sha256};
 use serde::Serialize;
 use std::collections::HashSet;
@@ -28,8 +28,7 @@ pub fn vendor(ws: &Workspace<'_>, opts: &VendorOptions<'_>) -> CargoResult<()> {
         extra_workspaces.push(ws);
     }
     let workspaces = extra_workspaces.iter().chain(Some(ws)).collect::<Vec<_>>();
-    let vendor_config =
-        sync(config, &workspaces, opts).chain_err(|| "failed to sync".to_string())?;
+    let vendor_config = sync(config, &workspaces, opts).with_context(|| "failed to sync")?;
 
     if config.shell().verbosity() != Verbosity::Quiet {
         crate::drop_eprint!(
@@ -104,11 +103,11 @@ fn sync(
     // crate to work with.
     for ws in workspaces {
         let (packages, resolve) =
-            ops::resolve_ws(ws).chain_err(|| "failed to load pkg lockfile")?;
+            ops::resolve_ws(ws).with_context(|| "failed to load pkg lockfile")?;
 
         packages
             .get_many(resolve.iter())
-            .chain_err(|| "failed to download packages")?;
+            .with_context(|| "failed to download packages")?;
 
         for pkg in resolve.iter() {
             // Don't delete actual source code!
@@ -136,11 +135,11 @@ fn sync(
     // tables about them.
     for ws in workspaces {
         let (packages, resolve) =
-            ops::resolve_ws(ws).chain_err(|| "failed to load pkg lockfile")?;
+            ops::resolve_ws(ws).with_context(|| "failed to load pkg lockfile")?;
 
         packages
             .get_many(resolve.iter())
-            .chain_err(|| "failed to download packages")?;
+            .with_context(|| "failed to download packages")?;
 
         for pkg in resolve.iter() {
             // No need to vendor path crates since they're already in the
@@ -152,7 +151,7 @@ fn sync(
                 pkg,
                 packages
                     .get_one(pkg)
-                    .chain_err(|| "failed to fetch package")?
+                    .with_context(|| "failed to fetch package")?
                     .clone(),
             );
 
@@ -216,7 +215,7 @@ fn sync(
         let paths = pathsource.list_files(pkg)?;
         let mut map = BTreeMap::new();
         cp_sources(src, &paths, &dst, &mut map, &mut tmp_buf)
-            .chain_err(|| format!("failed to copy over vendored sources for: {}", id))?;
+            .with_context(|| format!("failed to copy over vendored sources for: {}", id))?;
 
         // Finally, emit the metadata about this package
         let json = serde_json::json!({
@@ -341,7 +340,7 @@ fn cp_sources(
 }
 
 fn copy_and_checksum(src_path: &Path, dst_path: &Path, buf: &mut [u8]) -> CargoResult<String> {
-    let mut src = File::open(src_path).chain_err(|| format!("failed to open {:?}", src_path))?;
+    let mut src = File::open(src_path).with_context(|| format!("failed to open {:?}", src_path))?;
     let mut dst_opts = OpenOptions::new();
     dst_opts.write(true).create(true).truncate(true);
     #[cfg(unix)]
@@ -349,25 +348,25 @@ fn copy_and_checksum(src_path: &Path, dst_path: &Path, buf: &mut [u8]) -> CargoR
         use std::os::unix::fs::{MetadataExt, OpenOptionsExt};
         let src_metadata = src
             .metadata()
-            .chain_err(|| format!("failed to stat {:?}", src_path))?;
+            .with_context(|| format!("failed to stat {:?}", src_path))?;
         dst_opts.mode(src_metadata.mode());
     }
     let mut dst = dst_opts
         .open(dst_path)
-        .chain_err(|| format!("failed to create {:?}", dst_path))?;
+        .with_context(|| format!("failed to create {:?}", dst_path))?;
     // Not going to bother setting mode on pre-existing files, since there
     // shouldn't be any under normal conditions.
     let mut cksum = Sha256::new();
     loop {
         let n = src
             .read(buf)
-            .chain_err(|| format!("failed to read from {:?}", src_path))?;
+            .with_context(|| format!("failed to read from {:?}", src_path))?;
         if n == 0 {
             break Ok(cksum.finish_hex());
         }
         let data = &buf[..n];
         cksum.update(data);
         dst.write_all(data)
-            .chain_err(|| format!("failed to write to {:?}", dst_path))?;
+            .with_context(|| format!("failed to write to {:?}", dst_path))?;
     }
 }
diff --git a/src/cargo/sources/config.rs b/src/cargo/sources/config.rs
index 2af108d21c9..2ed18535d7d 100644
--- a/src/cargo/sources/config.rs
+++ b/src/cargo/sources/config.rs
@@ -7,9 +7,9 @@
 use crate::core::{GitReference, PackageId, Source, SourceId};
 use crate::sources::{ReplacedSource, CRATES_IO_REGISTRY};
 use crate::util::config::{self, ConfigRelativePath, OptValue};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::{Config, IntoUrl};
-use anyhow::bail;
+use anyhow::{bail, Context as _};
 use log::debug;
 use std::collections::{HashMap, HashSet};
 use url::Url;
@@ -280,7 +280,7 @@ restore the source replacement configuration to continue the build
         return Ok(());
 
         fn url(val: &config::Value<String>, key: &str) -> CargoResult<Url> {
-            let url = val.val.into_url().chain_err(|| {
+            let url = val.val.into_url().with_context(|| {
                 format!(
                     "configuration key `{}` specified an invalid \
                      URL (in {})",
diff --git a/src/cargo/sources/directory.rs b/src/cargo/sources/directory.rs
index cc1324087cd..244e1ba544f 100644
--- a/src/cargo/sources/directory.rs
+++ b/src/cargo/sources/directory.rs
@@ -5,8 +5,10 @@ use std::path::{Path, PathBuf};
 use crate::core::source::MaybePackage;
 use crate::core::{Dependency, Package, PackageId, Source, SourceId, Summary};
 use crate::sources::PathSource;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::Config;
+
+use anyhow::Context as _;
 use cargo_util::{paths, Sha256};
 use serde::Deserialize;
 
@@ -72,7 +74,7 @@ impl<'cfg> Source for DirectorySource<'cfg> {
 
     fn update(&mut self) -> CargoResult<()> {
         self.packages.clear();
-        let entries = self.root.read_dir().chain_err(|| {
+        let entries = self.root.read_dir().with_context(|| {
             format!(
                 "failed to read root of directory source: {}",
                 self.root.display()
@@ -116,7 +118,7 @@ impl<'cfg> Source for DirectorySource<'cfg> {
             let mut pkg = src.root_package()?;
 
             let cksum_file = path.join(".cargo-checksum.json");
-            let cksum = paths::read(&path.join(cksum_file)).chain_err(|| {
+            let cksum = paths::read(&path.join(cksum_file)).with_context(|| {
                 format!(
                     "failed to load checksum `.cargo-checksum.json` \
                      of {} v{}",
@@ -124,7 +126,7 @@ impl<'cfg> Source for DirectorySource<'cfg> {
                     pkg.package_id().version()
                 )
             })?;
-            let cksum: Checksum = serde_json::from_str(&cksum).chain_err(|| {
+            let cksum: Checksum = serde_json::from_str(&cksum).with_context(|| {
                 format!(
                     "failed to decode `.cargo-checksum.json` of \
                      {} v{}",
@@ -171,7 +173,7 @@ impl<'cfg> Source for DirectorySource<'cfg> {
             let file = pkg.root().join(file);
             let actual = Sha256::new()
                 .update_path(&file)
-                .chain_err(|| format!("failed to calculate checksum of: {}", file.display()))?
+                .with_context(|| format!("failed to calculate checksum of: {}", file.display()))?
                 .finish_hex();
             if &*actual != cksum {
                 anyhow::bail!(
diff --git a/src/cargo/sources/git/utils.rs b/src/cargo/sources/git/utils.rs
index fc23a2e221d..5b0d60a9887 100644
--- a/src/cargo/sources/git/utils.rs
+++ b/src/cargo/sources/git/utils.rs
@@ -2,9 +2,9 @@
 //! authentication/cloning.
 
 use crate::core::GitReference;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::{network, Config, IntoUrl, Progress};
-use anyhow::{anyhow, Context};
+use anyhow::{anyhow, Context as _};
 use cargo_util::{paths, ProcessBuilder};
 use curl::easy::List;
 use git2::{self, ErrorClass, ObjectType};
@@ -206,7 +206,7 @@ impl GitReference {
                 let obj = obj.peel(ObjectType::Commit)?;
                 Ok(obj.id())
             })()
-            .chain_err(|| format!("failed to find tag `{}`", s))?,
+            .with_context(|| format!("failed to find tag `{}`", s))?,
 
             // Resolve the remote name since that's all we're configuring in
             // `fetch` below.
@@ -214,7 +214,7 @@ impl GitReference {
                 let name = format!("origin/{}", s);
                 let b = repo
                     .find_branch(&name, git2::BranchType::Remote)
-                    .chain_err(|| format!("failed to find branch `{}`", s))?;
+                    .with_context(|| format!("failed to find branch `{}`", s))?;
                 b.get()
                     .target()
                     .ok_or_else(|| anyhow::format_err!("branch `{}` did not have a target", s))?
@@ -349,7 +349,7 @@ impl<'a> GitCheckout<'a> {
             info!("update submodules for: {:?}", repo.workdir().unwrap());
 
             for mut child in repo.submodules()? {
-                update_submodule(repo, &mut child, cargo_config).chain_err(|| {
+                update_submodule(repo, &mut child, cargo_config).with_context(|| {
                     format!(
                         "failed to update submodule `{}`",
                         child.name().unwrap_or("")
@@ -402,7 +402,7 @@ impl<'a> GitCheckout<'a> {
             cargo_config
                 .shell()
                 .status("Updating", format!("git submodule `{}`", url))?;
-            fetch(&mut repo, url, &reference, cargo_config).chain_err(|| {
+            fetch(&mut repo, url, &reference, cargo_config).with_context(|| {
                 format!(
                     "failed to fetch submodule `{}` from {}",
                     child.name().unwrap_or(""),
diff --git a/src/cargo/sources/path.rs b/src/cargo/sources/path.rs
index 0de72a1ba6b..06580348ad6 100644
--- a/src/cargo/sources/path.rs
+++ b/src/cargo/sources/path.rs
@@ -5,7 +5,8 @@ use std::path::{Path, PathBuf};
 use crate::core::source::MaybePackage;
 use crate::core::{Dependency, Package, PackageId, Source, SourceId, Summary};
 use crate::ops;
-use crate::util::{internal, CargoResult, CargoResultExt, Config};
+use crate::util::{internal, CargoResult, Config};
+use anyhow::Context as _;
 use cargo_util::paths;
 use filetime::FileTime;
 use ignore::gitignore::GitignoreBuilder;
@@ -96,7 +97,7 @@ impl<'cfg> PathSource<'cfg> {
     /// are relevant for building this package, but it also contains logic to
     /// use other methods like .gitignore to filter the list of files.
     pub fn list_files(&self, pkg: &Package) -> CargoResult<Vec<PathBuf>> {
-        self._list_files(pkg).chain_err(|| {
+        self._list_files(pkg).with_context(|| {
             format!(
                 "failed to determine list of files in {}",
                 pkg.root().display()
@@ -190,7 +191,7 @@ impl<'cfg> PathSource<'cfg> {
         };
         let index = repo
             .index()
-            .chain_err(|| format!("failed to open git index at {}", repo.path().display()))?;
+            .with_context(|| format!("failed to open git index at {}", repo.path().display()))?;
         let repo_root = repo.workdir().ok_or_else(|| {
             anyhow::format_err!(
                 "did not expect repo at {} to be bare",
@@ -411,7 +412,7 @@ impl<'cfg> PathSource<'cfg> {
         // TODO: drop `collect` and sort after transition period and dropping warning tests.
         // See rust-lang/cargo#4268 and rust-lang/cargo#4270.
         let mut entries: Vec<PathBuf> = fs::read_dir(path)
-            .chain_err(|| format!("cannot read {:?}", path))?
+            .with_context(|| format!("cannot read {:?}", path))?
             .map(|e| e.unwrap().path())
             .collect();
         entries.sort_unstable_by(|a, b| a.as_os_str().cmp(b.as_os_str()));
@@ -436,7 +437,7 @@ impl<'cfg> PathSource<'cfg> {
 
         let mut max = FileTime::zero();
         let mut max_path = PathBuf::new();
-        for file in self.list_files(pkg).chain_err(|| {
+        for file in self.list_files(pkg).with_context(|| {
             format!(
                 "failed to determine the most recently modified file in {}",
                 pkg.root().display()
diff --git a/src/cargo/sources/registry/mod.rs b/src/cargo/sources/registry/mod.rs
index d43a3d26da2..334053694bd 100644
--- a/src/cargo/sources/registry/mod.rs
+++ b/src/cargo/sources/registry/mod.rs
@@ -165,6 +165,7 @@ use std::fs::{File, OpenOptions};
 use std::io::Write;
 use std::path::{Path, PathBuf};
 
+use anyhow::Context as _;
 use flate2::read::GzDecoder;
 use log::debug;
 use semver::{Version, VersionReq};
@@ -175,7 +176,6 @@ use crate::core::dependency::{DepKind, Dependency};
 use crate::core::source::MaybePackage;
 use crate::core::{Package, PackageId, Source, SourceId, Summary};
 use crate::sources::PathSource;
-use crate::util::errors::CargoResultExt;
 use crate::util::hex;
 use crate::util::interning::InternedString;
 use crate::util::into_url::IntoUrl;
@@ -600,10 +600,10 @@ impl<'cfg> RegistrySource<'cfg> {
         let prefix = unpack_dir.file_name().unwrap();
         let parent = unpack_dir.parent().unwrap();
         for entry in tar.entries()? {
-            let mut entry = entry.chain_err(|| "failed to iterate over archive")?;
+            let mut entry = entry.with_context(|| "failed to iterate over archive")?;
             let entry_path = entry
                 .path()
-                .chain_err(|| "failed to read entry path")?
+                .with_context(|| "failed to read entry path")?
                 .into_owned();
 
             // We're going to unpack this tarball into the global source
@@ -623,7 +623,7 @@ impl<'cfg> RegistrySource<'cfg> {
             // Unpacking failed
             let mut result = entry.unpack_in(parent).map_err(anyhow::Error::from);
             if cfg!(windows) && restricted_names::is_windows_reserved_path(&entry_path) {
-                result = result.chain_err(|| {
+                result = result.with_context(|| {
                     format!(
                         "`{}` appears to contain a reserved Windows path, \
                         it cannot be extracted on Windows",
@@ -631,7 +631,8 @@ impl<'cfg> RegistrySource<'cfg> {
                     )
                 });
             }
-            result.chain_err(|| format!("failed to unpack entry at `{}`", entry_path.display()))?;
+            result
+                .with_context(|| format!("failed to unpack entry at `{}`", entry_path.display()))?;
         }
 
         // The lock file is created after unpacking so we overwrite a lock file
@@ -641,7 +642,7 @@ impl<'cfg> RegistrySource<'cfg> {
             .read(true)
             .write(true)
             .open(&path)
-            .chain_err(|| format!("failed to open `{}`", path.display()))?;
+            .with_context(|| format!("failed to open `{}`", path.display()))?;
 
         // Write to the lock file to indicate that unpacking was successful.
         write!(ok, "ok")?;
@@ -660,7 +661,7 @@ impl<'cfg> RegistrySource<'cfg> {
     fn get_pkg(&mut self, package: PackageId, path: &File) -> CargoResult<Package> {
         let path = self
             .unpack_package(package, path)
-            .chain_err(|| format!("failed to unpack package `{}`", package))?;
+            .with_context(|| format!("failed to unpack package `{}`", package))?;
         let mut src = PathSource::new(&path, self.source_id, self.config);
         src.update()?;
         let mut pkg = match src.download(package)? {
diff --git a/src/cargo/sources/registry/remote.rs b/src/cargo/sources/registry/remote.rs
index 890bb8a68c6..86ced22bc92 100644
--- a/src/cargo/sources/registry/remote.rs
+++ b/src/cargo/sources/registry/remote.rs
@@ -5,9 +5,10 @@ use crate::sources::registry::{
     RegistryConfig, RegistryData, CRATE_TEMPLATE, LOWER_PREFIX_TEMPLATE, PREFIX_TEMPLATE,
     VERSION_TEMPLATE,
 };
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
 use crate::util::{Config, Filesystem};
+use anyhow::Context as _;
 use cargo_util::{paths, Sha256};
 use lazycell::LazyCell;
 use log::{debug, trace};
@@ -97,7 +98,7 @@ impl<'cfg> RemoteRegistry<'cfg> {
                     let mut opts = git2::RepositoryInitOptions::new();
                     opts.external_template(false);
                     Ok(git2::Repository::init_opts(&path, &opts)
-                        .chain_err(|| "failed to initialize index git repository")?)
+                        .with_context(|| "failed to initialize index git repository")?)
                 }
             }
         })
@@ -241,7 +242,7 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> {
         let url = self.source_id.url();
         let repo = self.repo.borrow_mut().unwrap();
         git::fetch(repo, url.as_str(), &self.index_git_ref, self.config)
-            .chain_err(|| format!("failed to fetch `{}`", url))?;
+            .with_context(|| format!("failed to fetch `{}`", url))?;
         self.config.updated_sources().insert(self.source_id);
 
         // Create a dummy file to record the mtime for when we updated the
@@ -312,7 +313,7 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> {
             .read(true)
             .write(true)
             .open(&path)
-            .chain_err(|| format!("failed to open `{}`", path.display()))?;
+            .with_context(|| format!("failed to open `{}`", path.display()))?;
         let meta = dst.metadata()?;
         if meta.len() > 0 {
             return Ok(dst);
diff --git a/src/cargo/sources/replaced.rs b/src/cargo/sources/replaced.rs
index 7f4a622fd84..468df095cd6 100644
--- a/src/cargo/sources/replaced.rs
+++ b/src/cargo/sources/replaced.rs
@@ -1,6 +1,8 @@
 use crate::core::source::MaybePackage;
 use crate::core::{Dependency, Package, PackageId, Source, SourceId, Summary};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
+
+use anyhow::Context as _;
 
 pub struct ReplacedSource<'cfg> {
     to_replace: SourceId,
@@ -47,7 +49,7 @@ impl<'cfg> Source for ReplacedSource<'cfg> {
             .query(&dep, &mut |summary| {
                 f(summary.map_source(replace_with, to_replace))
             })
-            .chain_err(|| format!("failed to query replaced source {}", self.to_replace))?;
+            .with_context(|| format!("failed to query replaced source {}", self.to_replace))?;
         Ok(())
     }
 
@@ -59,14 +61,14 @@ impl<'cfg> Source for ReplacedSource<'cfg> {
             .fuzzy_query(&dep, &mut |summary| {
                 f(summary.map_source(replace_with, to_replace))
             })
-            .chain_err(|| format!("failed to query replaced source {}", self.to_replace))?;
+            .with_context(|| format!("failed to query replaced source {}", self.to_replace))?;
         Ok(())
     }
 
     fn update(&mut self) -> CargoResult<()> {
         self.inner
             .update()
-            .chain_err(|| format!("failed to update replaced source {}", self.to_replace))?;
+            .with_context(|| format!("failed to update replaced source {}", self.to_replace))?;
         Ok(())
     }
 
@@ -75,7 +77,7 @@ impl<'cfg> Source for ReplacedSource<'cfg> {
         let pkg = self
             .inner
             .download(id)
-            .chain_err(|| format!("failed to download replaced source {}", self.to_replace))?;
+            .with_context(|| format!("failed to download replaced source {}", self.to_replace))?;
         Ok(match pkg {
             MaybePackage::Ready(pkg) => {
                 MaybePackage::Ready(pkg.map_source(self.replace_with, self.to_replace))
@@ -89,7 +91,7 @@ impl<'cfg> Source for ReplacedSource<'cfg> {
         let pkg = self
             .inner
             .finish_download(id, data)
-            .chain_err(|| format!("failed to download replaced source {}", self.to_replace))?;
+            .with_context(|| format!("failed to download replaced source {}", self.to_replace))?;
         Ok(pkg.map_source(self.replace_with, self.to_replace))
     }
 
diff --git a/src/cargo/util/config/mod.rs b/src/cargo/util/config/mod.rs
index 8d7961f2f97..b9921dfee26 100644
--- a/src/cargo/util/config/mod.rs
+++ b/src/cargo/util/config/mod.rs
@@ -70,11 +70,11 @@ use crate::core::compiler::rustdoc::RustdocExternMap;
 use crate::core::shell::Verbosity;
 use crate::core::{features, CliUnstable, Shell, SourceId, Workspace};
 use crate::ops;
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::toml as cargo_toml;
 use crate::util::validate_package_name;
 use crate::util::{FileLock, Filesystem, IntoUrl, IntoUrlWithBase, Rustc};
-use anyhow::{anyhow, bail, format_err};
+use anyhow::{anyhow, bail, format_err, Context as _};
 use cargo_util::paths;
 use curl::easy::Easy;
 use lazycell::LazyCell;
@@ -294,8 +294,8 @@ impl Config {
     /// any config files from disk. Those will be loaded lazily as-needed.
     pub fn default() -> CargoResult<Config> {
         let shell = Shell::new();
-        let cwd =
-            env::current_dir().chain_err(|| "couldn't get the current directory of the process")?;
+        let cwd = env::current_dir()
+            .with_context(|| "couldn't get the current directory of the process")?;
         let homedir = homedir(&cwd).ok_or_else(|| {
             anyhow!(
                 "Cargo couldn't find your home directory. \
@@ -411,7 +411,7 @@ impl Config {
 
                 let exe = from_current_exe()
                     .or_else(|_| from_argv())
-                    .chain_err(|| "couldn't get the path to cargo executable")?;
+                    .with_context(|| "couldn't get the path to cargo executable")?;
                 Ok(exe)
             })
             .map(AsRef::as_ref)
@@ -1017,7 +1017,7 @@ impl Config {
             result.push(cv);
             Ok(())
         })
-        .chain_err(|| "could not load Cargo configuration")?;
+        .with_context(|| "could not load Cargo configuration")?;
         Ok(result)
     }
 
@@ -1029,9 +1029,9 @@ impl Config {
     ) -> CargoResult<()> {
         let includes = self.include_paths(cv, false)?;
         for (path, abs_path, def) in includes {
-            let mut cv = self
-                ._load_file(&abs_path, seen, false)
-                .chain_err(|| format!("failed to load config include `{}` from `{}`", path, def))?;
+            let mut cv = self._load_file(&abs_path, seen, false).with_context(|| {
+                format!("failed to load config include `{}` from `{}`", path, def)
+            })?;
             self.load_unmerged_include(&mut cv, seen, output)?;
             output.push(cv);
         }
@@ -1046,11 +1046,12 @@ impl Config {
 
         self.walk_tree(path, &home, |path| {
             let value = self.load_file(path, true)?;
-            cfg.merge(value, false)
-                .chain_err(|| format!("failed to merge configuration at `{}`", path.display()))?;
+            cfg.merge(value, false).with_context(|| {
+                format!("failed to merge configuration at `{}`", path.display())
+            })?;
             Ok(())
         })
-        .chain_err(|| "could not load Cargo configuration")?;
+        .with_context(|| "could not load Cargo configuration")?;
 
         match cfg {
             CV::Table(map, _) => Ok(map),
@@ -1076,15 +1077,17 @@ impl Config {
             );
         }
         let contents = fs::read_to_string(path)
-            .chain_err(|| format!("failed to read configuration file `{}`", path.display()))?;
-        let toml = cargo_toml::parse(&contents, path, self)
-            .chain_err(|| format!("could not parse TOML configuration in `{}`", path.display()))?;
-        let value = CV::from_toml(Definition::Path(path.to_path_buf()), toml).chain_err(|| {
-            format!(
-                "failed to load TOML configuration from `{}`",
-                path.display()
-            )
+            .with_context(|| format!("failed to read configuration file `{}`", path.display()))?;
+        let toml = cargo_toml::parse(&contents, path, self).with_context(|| {
+            format!("could not parse TOML configuration in `{}`", path.display())
         })?;
+        let value =
+            CV::from_toml(Definition::Path(path.to_path_buf()), toml).with_context(|| {
+                format!(
+                    "failed to load TOML configuration from `{}`",
+                    path.display()
+                )
+            })?;
         if includes {
             self.load_includes(value, seen)
         } else {
@@ -1109,7 +1112,9 @@ impl Config {
         for (path, abs_path, def) in includes {
             self._load_file(&abs_path, seen, true)
                 .and_then(|include| root.merge(include, true))
-                .chain_err(|| format!("failed to load config include `{}` from `{}`", path, def))?;
+                .with_context(|| {
+                    format!("failed to load config include `{}` from `{}`", path, def)
+                })?;
         }
         root.merge(value, true)?;
         Ok(root)
@@ -1181,7 +1186,7 @@ impl Config {
                 // TODO: This should probably use a more narrow parser, reject
                 // comments, blank lines, [headers], etc.
                 let toml_v: toml::Value = toml::de::from_str(arg)
-                    .chain_err(|| format!("failed to parse --config argument `{}`", arg))?;
+                    .with_context(|| format!("failed to parse --config argument `{}`", arg))?;
                 let toml_table = toml_v.as_table().unwrap();
                 if toml_table.len() != 1 {
                     bail!(
@@ -1191,15 +1196,15 @@ impl Config {
                     );
                 }
                 CV::from_toml(Definition::Cli, toml_v)
-                    .chain_err(|| format!("failed to convert --config argument `{}`", arg))?
+                    .with_context(|| format!("failed to convert --config argument `{}`", arg))?
             };
             let mut seen = HashSet::new();
             let tmp_table = self
                 .load_includes(tmp_table, &mut seen)
-                .chain_err(|| "failed to load --config include".to_string())?;
+                .with_context(|| "failed to load --config include".to_string())?;
             loaded_args
                 .merge(tmp_table, true)
-                .chain_err(|| format!("failed to merge --config argument `{}`", arg))?;
+                .with_context(|| format!("failed to merge --config argument `{}`", arg))?;
         }
         Ok(loaded_args)
     }
@@ -1218,7 +1223,7 @@ impl Config {
                 Vacant(entry) => {
                     entry.insert(value);
                 }
-                Occupied(mut entry) => entry.get_mut().merge(value, true).chain_err(|| {
+                Occupied(mut entry) => entry.get_mut().merge(value, true).with_context(|| {
                     format!(
                         "failed to merge --config key `{}` into `{}`",
                         entry.key(),
@@ -1304,7 +1309,7 @@ impl Config {
     pub fn get_registry_index(&self, registry: &str) -> CargoResult<Url> {
         validate_package_name(registry, "registry name", "")?;
         if let Some(index) = self.get_string(&format!("registries.{}.index", registry))? {
-            self.resolve_registry_index(&index).chain_err(|| {
+            self.resolve_registry_index(&index).with_context(|| {
                 format!(
                     "invalid index URL for registry `{}` defined in {}",
                     registry, index.definition
@@ -1573,7 +1578,7 @@ impl Config {
                             return Ok(PackageCacheLock(self));
                         }
 
-                        Err(e).chain_err(|| "failed to acquire package cache lock")?;
+                        Err(e).with_context(|| "failed to acquire package cache lock")?;
                     }
                 }
             }
@@ -1725,7 +1730,7 @@ impl ConfigValue {
                 val.into_iter()
                     .map(|(key, value)| {
                         let value = CV::from_toml(def.clone(), value)
-                            .chain_err(|| format!("failed to parse key `{}`", key))?;
+                            .with_context(|| format!("failed to parse key `{}`", key))?;
                         Ok((key, value))
                     })
                     .collect::<CargoResult<_>>()?,
@@ -1771,7 +1776,7 @@ impl ConfigValue {
                         Occupied(mut entry) => {
                             let new_def = value.definition().clone();
                             let entry = entry.get_mut();
-                            entry.merge(value, force).chain_err(|| {
+                            entry.merge(value, force).with_context(|| {
                                 format!(
                                     "failed to merge key `{}` between \
                                      {} and {}",
@@ -1904,7 +1909,7 @@ pub fn save_credentials(
     };
 
     let mut contents = String::new();
-    file.read_to_string(&mut contents).chain_err(|| {
+    file.read_to_string(&mut contents).with_context(|| {
         format!(
             "failed to read configuration file `{}`",
             file.path().display()
@@ -1973,10 +1978,10 @@ pub fn save_credentials(
     let contents = toml.to_string();
     file.seek(SeekFrom::Start(0))?;
     file.write_all(contents.as_bytes())
-        .chain_err(|| format!("failed to write to `{}`", file.path().display()))?;
+        .with_context(|| format!("failed to write to `{}`", file.path().display()))?;
     file.file().set_len(contents.len() as u64)?;
     set_permissions(file.file(), 0o600)
-        .chain_err(|| format!("failed to set permissions of `{}`", file.path().display()))?;
+        .with_context(|| format!("failed to set permissions of `{}`", file.path().display()))?;
 
     return Ok(());
 
diff --git a/src/cargo/util/errors.rs b/src/cargo/util/errors.rs
index 94e255bca53..8a371607725 100644
--- a/src/cargo/util/errors.rs
+++ b/src/cargo/util/errors.rs
@@ -9,27 +9,6 @@ use std::path::PathBuf;
 
 pub type CargoResult<T> = anyhow::Result<T>;
 
-// TODO: should delete this trait and just use `with_context` instead
-pub trait CargoResultExt<T, E> {
-    fn chain_err<F, D>(self, f: F) -> CargoResult<T>
-    where
-        F: FnOnce() -> D,
-        D: fmt::Display + Send + Sync + 'static;
-}
-
-impl<T, E> CargoResultExt<T, E> for Result<T, E>
-where
-    E: Into<Error>,
-{
-    fn chain_err<F, D>(self, f: F) -> CargoResult<T>
-    where
-        F: FnOnce() -> D,
-        D: fmt::Display + Send + Sync + 'static,
-    {
-        self.map_err(|e| e.into().context(f()))
-    }
-}
-
 #[derive(Debug)]
 pub struct HttpNot200 {
     pub code: u32,
diff --git a/src/cargo/util/flock.rs b/src/cargo/util/flock.rs
index 98a77865c37..dfdff110415 100644
--- a/src/cargo/util/flock.rs
+++ b/src/cargo/util/flock.rs
@@ -3,8 +3,9 @@ use std::io;
 use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::{Display, Path, PathBuf};
 
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::Config;
+use anyhow::Context as _;
 use cargo_util::paths;
 use sys::*;
 use termcolor::Color::Cyan;
@@ -224,7 +225,7 @@ impl Filesystem {
                     Err(anyhow::Error::from(e))
                 }
             })
-            .chain_err(|| format!("failed to open: {}", path.display()))?;
+            .with_context(|| format!("failed to open: {}", path.display()))?;
         match state {
             State::Exclusive => {
                 acquire(config, msg, &path, &|| try_lock_exclusive(&f), &|| {
@@ -313,7 +314,7 @@ fn acquire(
     let msg = format!("waiting for file lock on {}", msg);
     config.shell().status_with_color("Blocking", &msg, Cyan)?;
 
-    lock_block().chain_err(|| format!("failed to lock file: {}", path.display()))?;
+    lock_block().with_context(|| format!("failed to lock file: {}", path.display()))?;
     return Ok(());
 
     #[cfg(all(target_os = "linux", not(target_env = "musl")))]
diff --git a/src/cargo/util/mod.rs b/src/cargo/util/mod.rs
index cf9cc39d875..f7759174a79 100644
--- a/src/cargo/util/mod.rs
+++ b/src/cargo/util/mod.rs
@@ -5,7 +5,7 @@ pub use self::canonical_url::CanonicalUrl;
 pub use self::config::{homedir, Config, ConfigValue};
 pub use self::dependency_queue::DependencyQueue;
 pub use self::diagnostic_server::RustfixDiagnosticServer;
-pub use self::errors::{internal, CargoResult, CargoResultExt, CliResult, Test};
+pub use self::errors::{internal, CargoResult, CliResult, Test};
 pub use self::errors::{CargoTestError, CliError};
 pub use self::flock::{FileLock, Filesystem};
 pub use self::graph::Graph;
diff --git a/src/cargo/util/rustc.rs b/src/cargo/util/rustc.rs
index fd467b11317..54b7e4cac03 100644
--- a/src/cargo/util/rustc.rs
+++ b/src/cargo/util/rustc.rs
@@ -4,12 +4,13 @@ use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 
+use anyhow::Context as _;
 use cargo_util::{paths, ProcessBuilder, ProcessError};
 use log::{debug, info, warn};
 use serde::{Deserialize, Serialize};
 
 use crate::util::interning::InternedString;
-use crate::util::{profile, CargoResult, CargoResultExt, StableHasher};
+use crate::util::{profile, CargoResult, StableHasher};
 
 /// Information on the `rustc` executable
 #[derive(Debug)]
@@ -66,7 +67,7 @@ impl Rustc {
         };
 
         let host = InternedString::new(extract("host: ")?);
-        let version = semver::Version::parse(extract("release: ")?).chain_err(|| {
+        let version = semver::Version::parse(extract("release: ")?).with_context(|| {
             format!(
                 "rustc version does not appear to be a valid semver version, from:\n{}",
                 verbose_version
@@ -218,13 +219,13 @@ impl Cache {
             let output = cmd
                 .build_command()
                 .output()
-                .chain_err(|| format!("could not execute process {} (never executed)", cmd))?;
+                .with_context(|| format!("could not execute process {} (never executed)", cmd))?;
             let stdout = String::from_utf8(output.stdout)
                 .map_err(|e| anyhow::anyhow!("{}: {:?}", e, e.as_bytes()))
-                .chain_err(|| anyhow::anyhow!("`{}` didn't return utf8 output", cmd))?;
+                .with_context(|| format!("`{}` didn't return utf8 output", cmd))?;
             let stderr = String::from_utf8(output.stderr)
                 .map_err(|e| anyhow::anyhow!("{}: {:?}", e, e.as_bytes()))
-                .chain_err(|| anyhow::anyhow!("`{}` didn't return utf8 output", cmd))?;
+                .with_context(|| format!("`{}` didn't return utf8 output", cmd))?;
             self.data.outputs.insert(
                 key,
                 Output {
diff --git a/src/cargo/util/toml/mod.rs b/src/cargo/util/toml/mod.rs
index d37640229b0..5132428db35 100644
--- a/src/cargo/util/toml/mod.rs
+++ b/src/cargo/util/toml/mod.rs
@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::str;
 
-use anyhow::{anyhow, bail};
+use anyhow::{anyhow, bail, Context as _};
 use cargo_platform::Platform;
 use cargo_util::paths;
 use log::{debug, trace};
@@ -22,7 +22,7 @@ use crate::core::{Dependency, Manifest, PackageId, Summary, Target};
 use crate::core::{Edition, EitherManifest, Feature, Features, VirtualManifest, Workspace};
 use crate::core::{GitReference, PackageIdSpec, SourceId, WorkspaceConfig, WorkspaceRootConfig};
 use crate::sources::{CRATES_IO_INDEX, CRATES_IO_REGISTRY};
-use crate::util::errors::{CargoResult, CargoResultExt, ManifestError};
+use crate::util::errors::{CargoResult, ManifestError};
 use crate::util::interning::InternedString;
 use crate::util::{self, config::ConfigRelativePath, validate_package_name, Config, IntoUrl};
 
@@ -50,7 +50,7 @@ pub fn read_manifest(
     let contents = paths::read(path).map_err(|err| ManifestError::new(err, path.into()))?;
 
     do_read_manifest(&contents, path, source_id, config)
-        .chain_err(|| format!("failed to parse manifest at `{}`", path.display()))
+        .with_context(|| format!("failed to parse manifest at `{}`", path.display()))
         .map_err(|err| ManifestError::new(err, path.into()))
 }
 
@@ -1028,10 +1028,10 @@ impl TomlManifest {
         let edition = if let Some(ref edition) = project.edition {
             features
                 .require(Feature::edition())
-                .chain_err(|| "editions are unstable")?;
+                .with_context(|| "editions are unstable")?;
             edition
                 .parse()
-                .chain_err(|| "failed to parse the `edition` key")?
+                .with_context(|| "failed to parse the `edition` key")?
         } else {
             Edition::Edition2015
         };
@@ -1470,7 +1470,7 @@ impl TomlManifest {
         }
         let mut replace = Vec::new();
         for (spec, replacement) in self.replace.iter().flatten() {
-            let mut spec = PackageIdSpec::parse(spec).chain_err(|| {
+            let mut spec = PackageIdSpec::parse(spec).with_context(|| {
                 format!(
                     "replacements must specify a valid semver \
                      version to replace, but `{}` does not",
@@ -1514,7 +1514,7 @@ impl TomlManifest {
                     .config
                     .get_registry_index(url)
                     .or_else(|_| url.into_url())
-                    .chain_err(|| {
+                    .with_context(|| {
                         format!("[patch] entry `{}` should be a URL or registry name", url)
                     })?,
             };
diff --git a/src/cargo/util/toml/targets.rs b/src/cargo/util/toml/targets.rs
index 017613e8ec8..ffc72af65b1 100644
--- a/src/cargo/util/toml/targets.rs
+++ b/src/cargo/util/toml/targets.rs
@@ -20,9 +20,11 @@ use super::{
 };
 use crate::core::compiler::CrateType;
 use crate::core::{Edition, Feature, Features, Target};
-use crate::util::errors::{CargoResult, CargoResultExt};
+use crate::util::errors::CargoResult;
 use crate::util::restricted_names;
 
+use anyhow::Context as _;
+
 pub fn targets(
     features: &Features,
     manifest: &TomlManifest,
@@ -787,11 +789,11 @@ fn configure(features: &Features, toml: &TomlTarget, target: &mut Target) -> Car
     if let Some(edition) = toml.edition.clone() {
         features
             .require(Feature::edition())
-            .chain_err(|| "editions are unstable")?;
+            .with_context(|| "editions are unstable")?;
         target.set_edition(
             edition
                 .parse()
-                .chain_err(|| "failed to parse the `edition` key")?,
+                .with_context(|| "failed to parse the `edition` key")?,
         );
     }
     Ok(())