Auto merge of #14377 - mo8it:context, r=weihanglo

Use context instead of with_context

Replace `.with_context(|| "…")` with `.context("…")` to avoid calling a trivial closure. It is also shorter :)

On the other hand, use `.with_context(|| format!(…))` instead of `.context(format!(…))` to avoid unneeded string allocation.

Author: bors

crates/rustfix/tests/parse_and_replace.rs

@@ -164,8 +164,8 @@ fn test_rustfix_with_file<P: AsRef<Path>>(file: P, mode: &str) -> Result<(), Err
 
     debug!("next up: {:?}", file);
     let code = fs::read_to_string(file)?;
-    let errors =
-        compile_and_get_json_errors(file).context(format!("could compile {}", file.display()))?;
+    let errors = compile_and_get_json_errors(file)
+        .with_context(|| format!("could not compile {}", file.display()))?;
     let suggestions =
         rustfix::get_suggestions_from_json(&errors, &HashSet::new(), filter_suggestions)
             .context("could not load suggestions")?;
@@ -175,10 +175,8 @@ fn test_rustfix_with_file<P: AsRef<Path>>(file: P, mode: &str) -> Result<(), Err
     }
 
     if std::env::var(settings::CHECK_JSON).is_ok() {
-        let expected_json = fs::read_to_string(&json_file).context(format!(
-            "could not load json fixtures for {}",
-            file.display()
-        ))?;
+        let expected_json = fs::read_to_string(&json_file)
+            .with_context(|| format!("could not load json fixtures for {}", file.display()))?;
         let expected_suggestions =
             rustfix::get_suggestions_from_json(&expected_json, &HashSet::new(), filter_suggestions)
                 .context("could not load expected suggestions")?;
@@ -194,7 +192,7 @@ fn test_rustfix_with_file<P: AsRef<Path>>(file: P, mode: &str) -> Result<(), Err
     }
 
     let fixed = apply_suggestions(&code, &suggestions)
-        .context(format!("could not apply suggestions to {}", file.display()))?
+        .with_context(|| format!("could not apply suggestions to {}", file.display()))?
         .replace('\r', "");
 
     if std::env::var(settings::RECORD_FIXED_RUST).is_ok() {
@@ -209,7 +207,7 @@ fn test_rustfix_with_file<P: AsRef<Path>>(file: P, mode: &str) -> Result<(), Err
     }
 
     let expected_fixed = fs::read_to_string(&fixed_file)
-        .context(format!("could read fixed file for {}", file.display()))?
+        .with_context(|| format!("could read fixed file for {}", file.display()))?
         .replace('\r', "");
     ensure!(
         fixed.trim() == expected_fixed.trim(),
@@ -236,7 +234,7 @@ fn get_fixture_files(p: &str) -> Result<Vec<PathBuf>, Error> {
 
 fn assert_fixtures(dir: &str, mode: &str) {
     let files = get_fixture_files(dir)
-        .context(format!("couldn't load dir `{}`", dir))
+        .with_context(|| format!("couldn't load dir `{dir}`"))
         .unwrap();
     let mut failures = 0;
 

src/cargo/core/compiler/build_runner/mod.rs

@@ -100,8 +100,8 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
         let jobserver = match bcx.gctx.jobserver_from_env() {
             Some(c) => c.clone(),
             None => {
-                let client = Client::new(bcx.jobs() as usize)
-                    .with_context(|| "failed to create jobserver")?;
+                let client =
+                    Client::new(bcx.jobs() as usize).context("failed to create jobserver")?;
                 client.acquire_raw()?;
                 client
             }
@@ -354,11 +354,11 @@ impl<'a, 'gctx> BuildRunner<'a, 'gctx> {
             .unwrap()
             .host
             .prepare()
-            .with_context(|| "couldn't prepare build directories")?;
+            .context("couldn't prepare build directories")?;
         for target in self.files.as_mut().unwrap().target.values_mut() {
             target
                 .prepare()
-                .with_context(|| "couldn't prepare build directories")?;
+                .context("couldn't prepare build directories")?;
         }
 
         let files = self.files.as_ref().unwrap();

src/cargo/core/compiler/custom_build.rs

@@ -431,7 +431,7 @@ fn build_work(build_runner: &mut BuildRunner<'_, '_>, unit: &Unit) -> CargoResul
         // If we have an old build directory, then just move it into place,
         // otherwise create it!
         paths::create_dir_all(&script_out_dir)
-            .with_context(|| "failed to create script output directory for build command")?;
+            .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

src/cargo/core/compiler/future_incompat.rs

@@ -211,9 +211,9 @@ impl OnDiskReports {
         report_file
             .file()
             .read_to_string(&mut file_contents)
-            .with_context(|| "failed to read report")?;
+            .context("failed to read report")?;
         let on_disk_reports: OnDiskReports =
-            serde_json::from_str(&file_contents).with_context(|| "failed to load report")?;
+            serde_json::from_str(&file_contents).context("failed to load report")?;
         if on_disk_reports.version != ON_DISK_VERSION {
             bail!("unable to read reports; reports were saved from a future version of Cargo");
         }

src/cargo/core/compiler/job_queue/mod.rs

@@ -513,7 +513,7 @@ impl<'gctx> JobQueue<'gctx> {
             .into_helper_thread(move |token| {
                 messages.push(Message::Token(token));
             })
-            .with_context(|| "failed to create helper thread for jobserver management")?;
+            .context("failed to create helper thread for jobserver management")?;
 
         // Create a helper thread to manage the diagnostics for rustfix if
         // necessary.
@@ -700,7 +700,7 @@ impl<'gctx> DrainState<'gctx> {
                     .push(FutureIncompatReportPackage { package_id, items });
             }
             Message::Token(acquired_token) => {
-                let token = acquired_token.with_context(|| "failed to acquire jobserver token")?;
+                let token = acquired_token.context("failed to acquire jobserver token")?;
                 self.tokens.push(token);
             }
         }

src/cargo/core/compiler/timings.rs

@@ -299,7 +299,7 @@ impl<'gctx> Timings<'gctx> {
             .sort_unstable_by(|a, b| a.start.partial_cmp(&b.start).unwrap());
         if self.report_html {
             self.report_html(build_runner, error)
-                .with_context(|| "failed to save timing report")?;
+                .context("failed to save timing report")?;
         }
         Ok(())
     }

src/cargo/core/global_cache_tracker.rs

@@ -543,7 +543,7 @@ impl GlobalCacheTracker {
     /// Deletes files from the global cache based on the given options.
     pub fn clean(&mut self, clean_ctx: &mut CleanContext<'_>, gc_opts: &GcOpts) -> CargoResult<()> {
         self.clean_inner(clean_ctx, gc_opts)
-            .with_context(|| "failed to clean entries from the global cache")
+            .context("failed to clean entries from the global cache")
     }
 
     #[tracing::instrument(skip_all)]
@@ -575,7 +575,7 @@ impl GlobalCacheTracker {
                 gc_opts.is_download_cache_size_set(),
                 &mut delete_paths,
             )
-            .with_context(|| "failed to sync tracking database")?
+            .context("failed to sync tracking database")?
         }
         if let Some(max_age) = gc_opts.max_index_age {
             let max_age = now - max_age.as_secs();

src/cargo/core/package.rs

@@ -393,7 +393,7 @@ impl<'gctx> PackageSet<'gctx> {
         let multiplexing = gctx.http_config()?.multiplexing.unwrap_or(true);
         multi
             .pipelining(false, multiplexing)
-            .with_context(|| "failed to enable multiplexing/pipelining in curl")?;
+            .context("failed to enable multiplexing/pipelining in curl")?;
 
         // let's not flood crates.io with connections
         multi.set_max_host_connections(2)?;
@@ -681,7 +681,7 @@ impl<'a, 'gctx> Downloads<'a, 'gctx> {
             .ok_or_else(|| internal(format!("couldn't find source for `{}`", id)))?;
         let pkg = source
             .download(id)
-            .with_context(|| "unable to get packages from source")?;
+            .context("unable to get packages from source")?;
         let (url, descriptor, authorization) = match pkg {
             MaybePackage::Ready(pkg) => {
                 debug!("{} doesn't need a download", id);
@@ -951,7 +951,7 @@ impl<'a, 'gctx> Downloads<'a, 'gctx> {
                 self.set
                     .multi
                     .perform()
-                    .with_context(|| "failed to perform http requests")
+                    .context("failed to perform http requests")
             })?;
             debug!(target: "network", "handles remaining: {}", n);
             let results = &mut self.results;
@@ -981,7 +981,7 @@ impl<'a, 'gctx> Downloads<'a, 'gctx> {
                 self.set
                     .multi
                     .wait(&mut [], timeout)
-                    .with_context(|| "failed to wait on curl `Multi`")?;
+                    .context("failed to wait on curl `Multi`")?;
             }
         }
     }

src/cargo/core/registry.rs

@@ -444,8 +444,8 @@ impl<'gctx> PackageRegistry<'gctx> {
                         patches must point to different sources",
                         dep.package_name(),
                         url
-                    ))
-                    .context(format!("failed to resolve patches for `{}`", url));
+                    )
+                    .context(format!("failed to resolve patches for `{}`", url)));
                 }
                 unlocked_summaries.push(summary);
             }

src/cargo/ops/cargo_add/mod.rs

@@ -1085,10 +1085,9 @@ fn find_workspace_dep(toml_key: &str, root_manifest: &Path) -> CargoResult<Depen
         .context("could not find `dependencies` table in `workspace`")?
         .as_table_like()
         .context("could not make `dependencies` into a table")?;
-    let dep_item = dependencies.get(toml_key).context(format!(
-        "could not find {} in `workspace.dependencies`",
-        toml_key
-    ))?;
+    let dep_item = dependencies
+        .get(toml_key)
+        .with_context(|| format!("could not find {toml_key} in `workspace.dependencies`"))?;
     Dependency::from_toml(root_manifest.parent().unwrap(), toml_key, dep_item)
 }