From 0c2e0feaf390afe3325791af0028673622c156f2 Mon Sep 17 00:00:00 2001 From: Scott Schafer Date: Thu, 22 Sep 2022 12:52:02 -0600 Subject: [PATCH] switch to `std::task::ready!()` where possible --- src/cargo/core/registry.rs | 59 +++++++++-------------- src/cargo/sources/registry/http_remote.rs | 18 +++---- src/cargo/sources/registry/index.rs | 34 +++++-------- src/cargo/sources/registry/remote.rs | 9 ++-- 4 files changed, 44 insertions(+), 76 deletions(-) diff --git a/src/cargo/core/registry.rs b/src/cargo/core/registry.rs index 0d788a05c43..e20531b709c 100644 --- a/src/cargo/core/registry.rs +++ b/src/cargo/core/registry.rs @@ -1,5 +1,5 @@ use std::collections::{HashMap, HashSet}; -use std::task::Poll; +use std::task::{ready, Poll}; use crate::core::PackageSet; use crate::core::{Dependency, PackageId, QueryKind, Source, SourceId, SourceMap, Summary}; @@ -482,10 +482,7 @@ impl<'cfg> PackageRegistry<'cfg> { for &s in self.overrides.iter() { let src = self.sources.get_mut(s).unwrap(); let dep = Dependency::new_override(dep.package_name(), s); - let mut results = match src.query_vec(&dep, QueryKind::Exact) { - Poll::Ready(results) => results?, - Poll::Pending => return Poll::Pending, - }; + let mut results = ready!(src.query_vec(&dep, QueryKind::Exact))?; if !results.is_empty() { return Poll::Ready(Ok(Some(results.remove(0)))); } @@ -580,10 +577,7 @@ impl<'cfg> Registry for PackageRegistry<'cfg> { assert!(self.patches_locked); let (override_summary, n, to_warn) = { // Look for an override and get ready to query the real source. - let override_summary = match self.query_overrides(dep) { - Poll::Ready(override_summary) => override_summary?, - Poll::Pending => return Poll::Pending, - }; + let override_summary = ready!(self.query_overrides(dep))?; // Next up on our list of candidates is to check the `[patch]` // section of the manifest. Here we look through all patches @@ -880,23 +874,17 @@ fn summary_for_patch( // No summaries found, try to help the user figure out what is wrong. if let Some(locked) = locked { // Since the locked patch did not match anything, try the unlocked one. - let orig_matches = match source.query_vec(orig_patch, QueryKind::Exact) { - Poll::Pending => return Poll::Pending, - Poll::Ready(deps) => deps, - } - .unwrap_or_else(|e| { - log::warn!( - "could not determine unlocked summaries for dep {:?}: {:?}", - orig_patch, - e - ); - Vec::new() - }); + let orig_matches = + ready!(source.query_vec(orig_patch, QueryKind::Exact)).unwrap_or_else(|e| { + log::warn!( + "could not determine unlocked summaries for dep {:?}: {:?}", + orig_patch, + e + ); + Vec::new() + }); - let summary = match summary_for_patch(orig_patch, &None, orig_matches, source) { - Poll::Pending => return Poll::Pending, - Poll::Ready(summary) => summary?, - }; + let summary = ready!(summary_for_patch(orig_patch, &None, orig_matches, source))?; // The unlocked version found a match. This returns a value to // indicate that this entry should be unlocked. @@ -905,18 +893,15 @@ fn summary_for_patch( // Try checking if there are *any* packages that match this by name. let name_only_dep = Dependency::new_override(orig_patch.package_name(), orig_patch.source_id()); - let name_summaries = match source.query_vec(&name_only_dep, QueryKind::Exact) { - Poll::Pending => return Poll::Pending, - Poll::Ready(deps) => deps, - } - .unwrap_or_else(|e| { - log::warn!( - "failed to do name-only summary query for {:?}: {:?}", - name_only_dep, - e - ); - Vec::new() - }); + let name_summaries = + ready!(source.query_vec(&name_only_dep, QueryKind::Exact)).unwrap_or_else(|e| { + log::warn!( + "failed to do name-only summary query for {:?}: {:?}", + name_only_dep, + e + ); + Vec::new() + }); let mut vers = name_summaries .iter() .map(|summary| summary.version()) diff --git a/src/cargo/sources/registry/http_remote.rs b/src/cargo/sources/registry/http_remote.rs index 24b5660d090..1124e5fd181 100644 --- a/src/cargo/sources/registry/http_remote.rs +++ b/src/cargo/sources/registry/http_remote.rs @@ -19,7 +19,7 @@ use std::collections::{HashMap, HashSet}; use std::fs::{self, File}; use std::path::{Path, PathBuf}; use std::str; -use std::task::Poll; +use std::task::{ready, Poll}; use std::time::Duration; use url::Url; @@ -383,10 +383,7 @@ impl<'cfg> RegistryData for HttpRegistry<'cfg> { // Load the registry config. if self.registry_config.is_none() && path != Path::new("config.json") { - match self.config()? { - Poll::Ready(_) => {} - Poll::Pending => return Poll::Pending, - } + ready!(self.config()?); } let mut handle = ops::http_handle(self.config)?; @@ -515,11 +512,11 @@ impl<'cfg> RegistryData for HttpRegistry<'cfg> { } } - match self.load(Path::new(""), Path::new("config.json"), None)? { - Poll::Ready(LoadResponse::Data { + match ready!(self.load(Path::new(""), Path::new("config.json"), None)?) { + LoadResponse::Data { raw_data, index_version: _, - }) => { + } => { trace!("config loaded"); self.registry_config = Some(serde_json::from_slice(&raw_data)?); if paths::create_dir_all(&config_json_path.parent().unwrap()).is_ok() { @@ -529,13 +526,12 @@ impl<'cfg> RegistryData for HttpRegistry<'cfg> { } Poll::Ready(Ok(self.registry_config.clone())) } - Poll::Ready(LoadResponse::NotFound) => { + LoadResponse::NotFound => { Poll::Ready(Err(anyhow::anyhow!("config.json not found in registry"))) } - Poll::Ready(LoadResponse::CacheValid) => { + LoadResponse::CacheValid => { panic!("config.json is not stored in the index cache") } - Poll::Pending => Poll::Pending, } } diff --git a/src/cargo/sources/registry/index.rs b/src/cargo/sources/registry/index.rs index df0b7797d92..7b896a7db4f 100644 --- a/src/cargo/sources/registry/index.rs +++ b/src/cargo/sources/registry/index.rs @@ -80,7 +80,7 @@ use std::fs; use std::io::ErrorKind; use std::path::Path; use std::str; -use std::task::Poll; +use std::task::{ready, Poll}; /// Crates.io treats hyphen and underscores as interchangeable, but the index and old Cargo do not. /// Therefore, the index must store uncanonicalized version of the name so old Cargo's can find it. @@ -268,10 +268,7 @@ impl<'cfg> RegistryIndex<'cfg> { pub fn hash(&mut self, pkg: PackageId, load: &mut dyn RegistryData) -> Poll> { let req = OptVersionReq::exact(pkg.version()); let summary = self.summaries(pkg.name(), &req, load)?; - let summary = match summary { - Poll::Ready(mut summary) => summary.next(), - Poll::Pending => return Poll::Pending, - }; + let summary = ready!(summary).next(); Poll::Ready(Ok(summary .ok_or_else(|| internal(format!("no hash listed for {}", pkg)))? .summary @@ -302,10 +299,7 @@ impl<'cfg> RegistryIndex<'cfg> { // has run previously this will parse a Cargo-specific cache file rather // than the registry itself. In effect this is intended to be a quite // cheap operation. - let summaries = match self.load_summaries(name, load)? { - Poll::Ready(summaries) => summaries, - Poll::Pending => return Poll::Pending, - }; + let summaries = ready!(self.load_summaries(name, load)?); // Iterate over our summaries, extract all relevant ones which match our // version requirement, and then parse all corresponding rows in the @@ -422,12 +416,9 @@ impl<'cfg> RegistryIndex<'cfg> { f: &mut dyn FnMut(Summary), ) -> Poll> { if self.config.offline() { - match self.query_inner_with_online(dep, load, yanked_whitelist, f, false)? { - Poll::Ready(0) => {} - Poll::Ready(_) => return Poll::Ready(Ok(())), - Poll::Pending => return Poll::Pending, - } - // If offline, and there are no matches, try again with online. + // This should only return `Poll::Ready(Ok(()))` if there is at least 1 match. + // + // If there are 0 matches it should fall through and try again with online. // This is necessary for dependencies that are not used (such as // target-cfg or optional), but are not downloaded. Normally the // build should succeed if they are not downloaded and not used, @@ -435,6 +426,9 @@ impl<'cfg> RegistryIndex<'cfg> { // then cargo will fail to download and an error message // indicating that the required dependency is unavailable while // offline will be displayed. + if ready!(self.query_inner_with_online(dep, load, yanked_whitelist, f, false)?) > 0 { + return Poll::Ready(Ok(())); + } } self.query_inner_with_online(dep, load, yanked_whitelist, f, true) .map_ok(|_| ()) @@ -450,10 +444,7 @@ impl<'cfg> RegistryIndex<'cfg> { ) -> Poll> { let source_id = self.source_id; - let summaries = match self.summaries(dep.package_name(), dep.version_req(), load)? { - Poll::Ready(summaries) => summaries, - Poll::Pending => return Poll::Pending, - }; + let summaries = ready!(self.summaries(dep.package_name(), dep.version_req(), load))?; let summaries = summaries // First filter summaries for `--offline`. If we're online then @@ -582,10 +573,7 @@ impl Summaries { Err(e) => log::debug!("cache missing for {:?} error: {}", relative, e), } - let response = match load.load(root, relative, index_version.as_deref())? { - Poll::Pending => return Poll::Pending, - Poll::Ready(response) => response, - }; + let response = ready!(load.load(root, relative, index_version.as_deref())?); match response { LoadResponse::CacheValid => { diff --git a/src/cargo/sources/registry/remote.rs b/src/cargo/sources/registry/remote.rs index dcfc72ba045..e5f506bfca3 100644 --- a/src/cargo/sources/registry/remote.rs +++ b/src/cargo/sources/registry/remote.rs @@ -15,7 +15,7 @@ use std::fs::File; use std::mem; use std::path::Path; use std::str; -use std::task::Poll; +use std::task::{ready, Poll}; /// A remote registry is a registry that lives at a remote URL (such as /// crates.io). The git index is cloned locally, and `.crate` files are @@ -236,13 +236,12 @@ impl<'cfg> RegistryData for RemoteRegistry<'cfg> { debug!("loading config"); self.prepare()?; self.config.assert_package_cache_locked(&self.index_path); - match self.load(Path::new(""), Path::new("config.json"), None)? { - Poll::Ready(LoadResponse::Data { raw_data, .. }) => { + match ready!(self.load(Path::new(""), Path::new("config.json"), None)?) { + LoadResponse::Data { raw_data, .. } => { trace!("config loaded"); Poll::Ready(Ok(Some(serde_json::from_slice(&raw_data)?))) } - Poll::Ready(_) => Poll::Ready(Ok(None)), - Poll::Pending => Poll::Pending, + _ => Poll::Ready(Ok(None)), } }