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

Signed-off-by: Nick Cameron <nrc@ncameron.org>

Author: nrc

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"

src/cargo/util/hasher.rs renamed to crates/cargo-util/src/hasher.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/util/hex.rs renamed to crates/cargo-util/src/hex.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;

crates/cargo-util/src/lib.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/compile_kind.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/context/compilation_files.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/fingerprint.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;