Refactoring: move hex and hasher modules from util module to util crate

Cargo.toml

@@ -18,7 +18,7 @@ path = "src/cargo/lib.rs"
 [dependencies]
 bytesize = "1.0"
 cargo-platform = { path = "crates/cargo-platform", version = "0.1.2" }
-cargo-util = { path = "crates/cargo-util", version = "0.2.3" }
+cargo-util = { path = "crates/cargo-util", version = "0.2.4" }
 crates-io = { path = "crates/crates-io", version = "0.35.0" }
 curl = { version = "0.4.44", features = ["http2"] }
 curl-sys = "0.4.59"

crates/cargo-util/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cargo-util"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 homepage = "https://github.com/rust-lang/cargo"

crates/cargo-util/src/lib.rs

@@ -1,10 +1,14 @@
 //! Miscellaneous support code used by Cargo.
 
+pub use self::hasher::StableHasher;
+pub use self::hex::{hash_u64, short_hash, to_hex};
 pub use self::read2::read2;
 pub use process_builder::ProcessBuilder;
 pub use process_error::{exit_status_to_string, is_simple_exit_code, ProcessError};
 pub use sha256::Sha256;
 
+mod hasher;
+pub mod hex;
 pub mod paths;
 mod process_builder;
 mod process_error;

src/cargo/core/compiler/compile_kind.rs

@@ -1,8 +1,9 @@
 use crate::core::Target;
 use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
-use crate::util::{Config, StableHasher};
+use crate::util::Config;
 use anyhow::Context as _;
+use cargo_util::StableHasher;
 use serde::Serialize;
 use std::collections::BTreeSet;
 use std::fs;

src/cargo/core/compiler/context/compilation_files.rs

@@ -5,13 +5,14 @@ use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
+use cargo_util::{short_hash, StableHasher};
 use lazycell::LazyCell;
 use log::debug;
 
 use super::{BuildContext, CompileKind, Context, FileFlavor, Layout};
 use crate::core::compiler::{CompileMode, CompileTarget, CrateType, FileType, Unit};
 use crate::core::{Target, TargetKind, Workspace};
-use crate::util::{self, CargoResult, StableHasher};
+use crate::util::CargoResult;
 
 /// This is a generic version number that can be changed to make
 /// backwards-incompatible changes to any file structures in the output
@@ -185,7 +186,7 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
     /// Used for the metadata when `metadata` returns `None`.
     pub fn target_short_hash(&self, unit: &Unit) -> String {
         let hashable = unit.pkg.package_id().stable_hash(self.ws.root());
-        util::short_hash(&(METADATA_VERSION, hashable))
+        short_hash(&(METADATA_VERSION, hashable))
     }
 
     /// Returns the directory where the artifacts for the given unit are

src/cargo/core/compiler/fingerprint.rs

@@ -322,7 +322,7 @@ use std::sync::{Arc, Mutex};
 use std::time::SystemTime;
 
 use anyhow::{bail, format_err, Context as _};
-use cargo_util::{paths, ProcessBuilder};
+use cargo_util::{hash_u64, paths, to_hex, ProcessBuilder, StableHasher};
 use filetime::FileTime;
 use log::{debug, info};
 use serde::de;
@@ -331,10 +331,9 @@ use serde::{Deserialize, Serialize};
 
 use crate::core::compiler::unit_graph::UnitDep;
 use crate::core::Package;
-use crate::util;
 use crate::util::errors::CargoResult;
 use crate::util::interning::InternedString;
-use crate::util::{internal, path_args, profile, StableHasher};
+use crate::util::{internal, path_args, profile};
 use crate::CARGO_ENV;
 
 use super::custom_build::BuildDeps;
@@ -812,7 +811,7 @@ impl Fingerprint {
         if let Some(s) = *self.memoized_hash.lock().unwrap() {
             return s;
         }
-        let ret = util::hash_u64(self);
+        let ret = hash_u64(self);
         *self.memoized_hash.lock().unwrap() = Some(ret);
         ret
     }
@@ -1160,9 +1159,9 @@ impl DepFingerprint {
         // `path` then we just hash the name, but otherwise we hash the full
         // id as it won't change when the directory is renamed.
         let pkg_id = if dep.unit.pkg.package_id().source_id().is_path() {
-            util::hash_u64(dep.unit.pkg.package_id().name())
+            hash_u64(dep.unit.pkg.package_id().name())
         } else {
-            util::hash_u64(dep.unit.pkg.package_id())
+            hash_u64(dep.unit.pkg.package_id())
         };
 
         Ok(DepFingerprint {
@@ -1309,15 +1308,15 @@ fn calculate_normal(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Finger
     }
     .to_vec();
 
-    let profile_hash = util::hash_u64((
+    let profile_hash = hash_u64((
         &unit.profile,
         unit.mode,
         cx.bcx.extra_args_for(unit),
         cx.lto[unit],
     ));
     // Include metadata since it is exposed as environment variables.
     let m = unit.pkg.manifest().metadata();
-    let metadata = util::hash_u64((&m.authors, &m.description, &m.homepage, &m.repository));
+    let metadata = hash_u64((&m.authors, &m.description, &m.homepage, &m.repository));
     let mut config = StableHasher::new();
     if let Some(linker) = cx.bcx.linker(unit.kind) {
         linker.hash(&mut config);
@@ -1332,12 +1331,12 @@ fn calculate_normal(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Finger
     }
     let compile_kind = unit.kind.fingerprint_hash();
     Ok(Fingerprint {
-        rustc: util::hash_u64(&cx.bcx.rustc().verbose_version),
-        target: util::hash_u64(&unit.target),
+        rustc: hash_u64(&cx.bcx.rustc().verbose_version),
+        target: hash_u64(&unit.target),
         profile: profile_hash,
         // Note that .0 is hashed here, not .1 which is the cwd. That doesn't
         // actually affect the output artifact so there's no need to hash it.
-        path: util::hash_u64(path_args(cx.bcx.ws, unit).0),
+        path: hash_u64(path_args(cx.bcx.ws, unit).0),
         features: format!("{:?}", unit.features),
         deps,
         local: Mutex::new(local),
@@ -1402,7 +1401,7 @@ See https://doc.rust-lang.org/cargo/reference/build-scripts.html#rerun-if-change
 
     Ok(Fingerprint {
         local: Mutex::new(local),
-        rustc: util::hash_u64(&cx.bcx.rustc().verbose_version),
+        rustc: hash_u64(&cx.bcx.rustc().verbose_version),
         deps,
         outputs: if overridden { Vec::new() } else { vec![output] },
 
@@ -1532,10 +1531,7 @@ fn build_script_override_fingerprint(
     let metadata = cx.get_run_build_script_metadata(unit);
     // Returns None if it is not overridden.
     let output = build_script_outputs.get(metadata)?;
-    let s = format!(
-        "overridden build state with hash: {}",
-        util::hash_u64(output)
-    );
+    let s = format!("overridden build state with hash: {}", hash_u64(output));
     Some(LocalFingerprint::Precalculated(s))
 }
 
@@ -1586,7 +1582,7 @@ fn write_fingerprint(loc: &Path, fingerprint: &Fingerprint) -> CargoResult<()> {
     // as we can use the full hash.
     let hash = fingerprint.hash_u64();
     debug!("write fingerprint ({:x}) : {}", hash, loc.display());
-    paths::write(loc, util::to_hex(hash).as_bytes())?;
+    paths::write(loc, to_hex(hash).as_bytes())?;
 
     let json = serde_json::to_string(fingerprint).unwrap();
     if cfg!(debug_assertions) {
@@ -1637,7 +1633,7 @@ fn compare_old_fingerprint(
 
     let new_hash = new_fingerprint.hash_u64();
 
-    if util::to_hex(new_hash) == old_fingerprint_short && new_fingerprint.fs_status.up_to_date() {
+    if to_hex(new_hash) == old_fingerprint_short && new_fingerprint.fs_status.up_to_date() {
         return Ok(());
     }
 
@@ -1646,10 +1642,7 @@ fn compare_old_fingerprint(
         .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_u64()),
-            old_fingerprint_short
-        );
+        debug_assert_eq!(to_hex(old_fingerprint.hash_u64()), old_fingerprint_short);
     }
     let result = new_fingerprint.compare(&old_fingerprint);
     assert!(result.is_err());

src/cargo/core/compiler/job_queue.rs

@@ -59,7 +59,7 @@ use std::thread::{self, Scope};
 use std::time::Duration;
 
 use anyhow::{format_err, Context as _};
-use cargo_util::ProcessBuilder;
+use cargo_util::{hash_u64, ProcessBuilder};
 use jobserver::{Acquired, Client, HelperThread};
 use log::{debug, trace};
 use semver::Version;
@@ -312,7 +312,7 @@ impl<'cfg> DiagDedupe<'cfg> {
     /// Returns `true` if the message was emitted, or `false` if it was
     /// suppressed for being a duplicate.
     fn emit_diag(&self, diag: &str) -> CargoResult<bool> {
-        let h = util::hash_u64(diag);
+        let h = hash_u64(diag);
         if !self.seen.borrow_mut().insert(h) {
             return Ok(false);
         }

src/cargo/core/compiler/unit.rs

@@ -1,9 +1,9 @@
 use crate::core::compiler::{unit_dependencies::IsArtifact, CompileKind, CompileMode, CrateType};
 use crate::core::manifest::{Target, TargetKind};
 use crate::core::{profiles::Profile, Package};
-use crate::util::hex::short_hash;
 use crate::util::interning::InternedString;
 use crate::util::Config;
+use cargo_util::hex::short_hash;
 use std::cell::RefCell;
 use std::collections::HashSet;
 use std::fmt;

src/cargo/core/manifest.rs

@@ -20,7 +20,8 @@ use crate::core::{Edition, Feature, Features, WorkspaceConfig};
 use crate::util::errors::*;
 use crate::util::interning::InternedString;
 use crate::util::toml::{TomlManifest, TomlProfiles};
-use crate::util::{short_hash, Config, Filesystem};
+use crate::util::{Config, Filesystem};
+use cargo_util::hex::short_hash;
 
 pub enum EitherManifest {
     Real(Manifest),

src/cargo/core/source/source_id.rs

@@ -712,7 +712,7 @@ impl Ord for SourceKind {
 fn test_cratesio_hash() {
     let config = Config::default().unwrap();
     let crates_io = SourceId::crates_io(&config).unwrap();
-    assert_eq!(crate::util::hex::short_hash(&crates_io), "1ecc6299db9ec823");
+    assert_eq!(cargo_util::hex::short_hash(&crates_io), "1ecc6299db9ec823");
 }
 
 /// A `Display`able view into a `SourceId` that will write it as a url

src/cargo/ops/cargo_compile/mod.rs

@@ -52,7 +52,8 @@ use crate::ops::resolve::WorkspaceResolve;
 use crate::util::config::Config;
 use crate::util::interning::InternedString;
 use crate::util::restricted_names::is_glob_pattern;
-use crate::util::{closest_msg, profile, CargoResult, StableHasher};
+use crate::util::{closest_msg, profile, CargoResult};
+use cargo_util::StableHasher;
 
 mod compile_filter;
 pub use compile_filter::{CompileFilter, FilterRule, LibRule};

src/cargo/ops/cargo_package.rs

@@ -14,10 +14,10 @@ use crate::core::{Package, PackageId, PackageSet, Resolve, SourceId};
 use crate::sources::PathSource;
 use crate::util::errors::CargoResult;
 use crate::util::toml::TomlManifest;
-use crate::util::{self, human_readable_bytes, restricted_names, Config, FileLock};
+use crate::util::{human_readable_bytes, restricted_names, Config, FileLock};
 use crate::{drop_println, ops};
 use anyhow::Context as _;
-use cargo_util::paths;
+use cargo_util::{hex, paths};
 use flate2::read::GzDecoder;
 use flate2::{Compression, GzBuilder};
 use log::debug;
@@ -885,13 +885,13 @@ fn hash_all(path: &Path) -> CargoResult<HashMap<PathBuf, u64>> {
             let file_type = entry.file_type();
             if file_type.is_file() {
                 let file = File::open(entry.path())?;
-                let hash = util::hex::hash_u64_file(&file)?;
+                let hash = hex::hash_u64_file(&file)?;
                 result.insert(entry.path().to_path_buf(), hash);
             } else if file_type.is_symlink() {
-                let hash = util::hex::hash_u64(&fs::read_link(entry.path())?);
+                let hash = hex::hash_u64(&fs::read_link(entry.path())?);
                 result.insert(entry.path().to_path_buf(), hash);
             } else if file_type.is_dir() {
-                let hash = util::hex::hash_u64(&());
+                let hash = hex::hash_u64(&());
                 result.insert(entry.path().to_path_buf(), hash);
             }
         }

src/cargo/sources/git/source.rs

@@ -4,9 +4,9 @@ use crate::core::{Dependency, Package, PackageId, Summary};
 use crate::sources::git::utils::GitRemote;
 use crate::sources::PathSource;
 use crate::util::errors::CargoResult;
-use crate::util::hex::short_hash;
 use crate::util::Config;
 use anyhow::Context;
+use cargo_util::hex::short_hash;
 use cargo_util::paths::exclude_from_backups_and_indexing;
 use log::trace;
 use std::fmt::{self, Debug, Formatter};

src/cargo/sources/registry/mod.rs

@@ -167,6 +167,7 @@ use std::path::{Path, PathBuf};
 use std::task::Poll;
 
 use anyhow::Context as _;
+use cargo_util::hex;
 use cargo_util::paths::exclude_from_backups_and_indexing;
 use flate2::read::GzDecoder;
 use log::debug;
@@ -178,7 +179,6 @@ use crate::core::dependency::{DepKind, Dependency};
 use crate::core::source::MaybePackage;
 use crate::core::{Package, PackageId, QueryKind, Source, SourceId, Summary};
 use crate::sources::PathSource;
-use crate::util::hex;
 use crate::util::interning::InternedString;
 use crate::util::into_url::IntoUrl;
 use crate::util::network::PollExt;

src/cargo/util/mod.rs

@@ -10,8 +10,6 @@ pub use self::errors::CliError;
 pub use self::errors::{internal, CargoResult, CliResult};
 pub use self::flock::{FileLock, Filesystem};
 pub use self::graph::Graph;
-pub use self::hasher::StableHasher;
-pub use self::hex::{hash_u64, short_hash, to_hex};
 pub use self::into_url::IntoUrl;
 pub use self::into_url_with_base::IntoUrlWithBase;
 pub(crate) use self::io::LimitErrorReader;
@@ -40,8 +38,6 @@ pub mod diagnostic_server;
 pub mod errors;
 mod flock;
 pub mod graph;
-mod hasher;
-pub mod hex;
 pub mod important_paths;
 pub mod interning;
 pub mod into_url;

src/cargo/util/rustc.rs

@@ -5,12 +5,12 @@ use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 
 use anyhow::Context as _;
-use cargo_util::{paths, ProcessBuilder, ProcessError};
+use cargo_util::{paths, ProcessBuilder, ProcessError, StableHasher};
 use log::{debug, info, warn};
 use serde::{Deserialize, Serialize};
 
 use crate::util::interning::InternedString;
-use crate::util::{profile, CargoResult, StableHasher};
+use crate::util::{profile, CargoResult};
 
 /// Information on the `rustc` executable
 #[derive(Debug)]

tests/testsuite/registry.rs

@@ -2593,7 +2593,7 @@ fn package_lock_inside_package_is_overwritten() {
     p.cargo("build").run();
 
     let id = SourceId::for_registry(registry.index_url()).unwrap();
-    let hash = cargo::util::hex::short_hash(&id);
+    let hash = cargo_util::hex::short_hash(&id);
     let ok = cargo_home()
         .join("registry")
         .join("src")
@@ -2631,7 +2631,7 @@ fn package_lock_as_a_symlink_inside_package_is_overwritten() {
     p.cargo("build").run();
 
     let id = SourceId::for_registry(registry.index_url()).unwrap();
-    let hash = cargo::util::hex::short_hash(&id);
+    let hash = cargo_util::hex::short_hash(&id);
     let pkg_root = cargo_home()
         .join("registry")
         .join("src")