refactor: remove unnecessary Option in Freshness::Dirty

src/cargo/core/compiler/custom_build.rs

@@ -34,6 +34,7 @@
 use super::{fingerprint, Context, Job, Unit, Work};
 use crate::core::compiler::artifact;
 use crate::core::compiler::context::Metadata;
+use crate::core::compiler::fingerprint::DirtyReason;
 use crate::core::compiler::job_queue::JobState;
 use crate::core::{profiles::ProfileRoot, PackageId, Target};
 use crate::util::errors::CargoResult;
@@ -608,7 +609,7 @@ fn build_work(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Job> {
  });
 
  let mut job = if cx.bcx.build_config.build_plan {
- Job::new_dirty(Work::noop(), None)
+ Job::new_dirty(Work::noop(), DirtyReason::FreshBuild)
  } else {
  fingerprint::prepare_target(cx, unit, false)?
  };

src/cargo/core/compiler/fingerprint/dirty_reason.rs

@@ -77,6 +77,8 @@ pub enum DirtyReason {
  FsStatusOutdated(FsStatus),
  NothingObvious,
  Forced,
+ /// First time to build something.
+ FreshBuild,
 }
 
 trait ShellExt {
@@ -131,6 +133,11 @@ impl fmt::Display for After {
 }
 
 impl DirtyReason {
+ /// Whether a build is dirty because it is a fresh build being kicked off.
+ pub fn is_fresh_build(&self) -> bool {
+ matches!(self, DirtyReason::FreshBuild)
+ }
+
  fn after(old_time: FileTime, new_time: FileTime, what: &'static str) -> After {
  After {
  old_time,
@@ -257,6 +264,7 @@ impl DirtyReason {
  s.dirty_because(unit, "the fingerprint comparison turned up nothing obvious")
  }
  DirtyReason::Forced => s.dirty_because(unit, "forced"),
+ DirtyReason::FreshBuild => s.dirty_because(unit, "fresh build"),
  }
  }
 }

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

@@ -415,43 +415,27 @@ pub fn prepare_target(cx: &mut Context<'_, '_>, unit: &Unit, force: bool) -> Car
  // information about failed comparisons to aid in debugging.
  let fingerprint = calculate(cx, unit)?;
  let mtime_on_use = cx.bcx.config.cli_unstable().mtime_on_use;
- let compare = compare_old_fingerprint(&loc, &*fingerprint, mtime_on_use);
- log_compare(unit, &compare);
+ let dirty_reason = compare_old_fingerprint(unit, &loc, &*fingerprint, mtime_on_use, force);
 
- // If our comparison failed or reported dirty (e.g., we're going to trigger
- // a rebuild of this crate), then we also ensure the source of the crate
- // passes all verification checks before we build it.
+ let Some(dirty_reason) = dirty_reason else {
+ return Ok(Job::new_fresh());
+ };
+
+ // We're going to rebuild, so ensure the source of the crate passes all
+ // verification checks before we build it.
  //
  // The `Source::verify` method is intended to allow sources to execute
  // pre-build checks to ensure that the relevant source code is all
  // up-to-date and as expected. This is currently used primarily for
  // directory sources which will use this hook to perform an integrity check
  // on all files in the source to ensure they haven't changed. If they have
  // changed then an error is issued.
- if compare
- .as_ref()
- .map(|dirty| dirty.is_some())
- .unwrap_or(true)
- {
- let source_id = unit.pkg.package_id().source_id();
- let sources = bcx.packages.sources();
- let source = sources
- .get(source_id)
- .ok_or_else(|| internal("missing package source"))?;
- source.verify(unit.pkg.package_id())?;
- }
-
- let dirty_reason = match compare {
- Ok(None) => {
- if force {
- Some(DirtyReason::Forced)
- } else {
- return Ok(Job::new_fresh());
- }
- }
- Ok(reason) => reason,
- Err(_) => None,
- };
+ let source_id = unit.pkg.package_id().source_id();
+ let sources = bcx.packages.sources();
+ let source = sources
+ .get(source_id)
+ .ok_or_else(|| internal("missing package source"))?;
+ source.verify(unit.pkg.package_id())?;
 
  // Clear out the old fingerprint file if it exists. This protects when
  // compilation is interrupted leaving a corrupt file. For example, a
@@ -1752,19 +1736,52 @@ fn target_root(cx: &Context<'_, '_>) -> PathBuf {
 /// If dirty, it then restores the detailed information
 /// from the fingerprint JSON file, and provides an rich dirty reason.
 fn compare_old_fingerprint(
+ unit: &Unit,
  old_hash_path: &Path,
  new_fingerprint: &Fingerprint,
  mtime_on_use: bool,
-) -> CargoResult<Option<DirtyReason>> {
- let old_fingerprint_short = paths::read(old_hash_path)?;
-
+ forced: bool,
+) -> Option<DirtyReason> {
  if mtime_on_use {
  // update the mtime so other cleaners know we used it
  let t = FileTime::from_system_time(SystemTime::now());
  debug!("mtime-on-use forcing {:?} to {}", old_hash_path, t);
  paths::set_file_time_no_err(old_hash_path, t);
  }
 
+ let compare = _compare_old_fingerprint(old_hash_path, new_fingerprint);
+
+ match compare.as_ref() {
+ Ok(None) => {}
+ Ok(Some(reason)) => {
+ info!(
+ "fingerprint dirty for {}/{:?}/{:?}",
+ unit.pkg, unit.mode, unit.target,
+ );
+ info!(" dirty: {reason:?}");
+ }
+ Err(e) => {
+ info!(
+ "fingerprint error for {}/{:?}/{:?}",
+ unit.pkg, unit.mode, unit.target,
+ );
+ info!(" err: {e:?}");
+ }
+ }
+
+ match compare {
+ Ok(None) if forced => Some(DirtyReason::Forced),
+ Ok(reason) => reason,
+ Err(_) => Some(DirtyReason::FreshBuild),
+ }
+}
+
+fn _compare_old_fingerprint(
+ old_hash_path: &Path,
+ new_fingerprint: &Fingerprint,
+) -> CargoResult<Option<DirtyReason>> {
+ let old_fingerprint_short = paths::read(old_hash_path)?;
+
  let new_hash = new_fingerprint.hash_u64();
 
  if util::to_hex(new_hash) == old_fingerprint_short && new_fingerprint.fs_status.up_to_date() {
@@ -1785,29 +1802,6 @@ fn compare_old_fingerprint(
  Ok(Some(new_fingerprint.compare(&old_fingerprint)))
 }
 
-/// Logs the result of fingerprint comparison.
-///
-/// TODO: Obsolete and mostly superseded by [`DirtyReason`]. Could be removed.
-fn log_compare(unit: &Unit, compare: &CargoResult<Option<DirtyReason>>) {
- match compare {
- Ok(None) => {}
- Ok(Some(reason)) => {
- info!(
- "fingerprint dirty for {}/{:?}/{:?}",
- unit.pkg, unit.mode, unit.target,
- );
- info!(" dirty: {reason:?}");
- }
- Err(e) => {
- info!(
- "fingerprint error for {}/{:?}/{:?}",
- unit.pkg, unit.mode, unit.target,
- );
- info!(" err: {e:?}");
- }
- }
-}
-
 /// Parses Cargo's internal [`EncodedDepInfo`] structure that was previously
 /// serialized to disk.
 ///

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

@@ -60,7 +60,7 @@ impl Job {
  }
 
  /// Creates a new job representing a unit of work.
- pub fn new_dirty(work: Work, dirty_reason: Option<DirtyReason>) -> Job {
+ pub fn new_dirty(work: Work, dirty_reason: DirtyReason) -> Job {
  Job {
  work,
  fresh: Freshness::Dirty(dirty_reason),
@@ -100,7 +100,7 @@ impl fmt::Debug for Job {
 #[derive(Debug, Clone)]
 pub enum Freshness {
  Fresh,
- Dirty(Option<DirtyReason>),
+ Dirty(DirtyReason),
 }
 
 impl Freshness {

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

@@ -1110,10 +1110,10 @@ impl<'cfg> DrainState<'cfg> {
  // Any dirty stage which runs at least one command gets printed as
  // being a compiled package.
  Dirty(dirty_reason) => {
- if let Some(reason) = dirty_reason {
+ if !dirty_reason.is_fresh_build() {
  config
  .shell()
- .verbose(|shell| reason.present_to(shell, unit, ws_root))?;
+ .verbose(|shell| dirty_reason.present_to(shell, unit, ws_root))?;
  }
 
  if unit.mode.is_doc() {

src/cargo/core/compiler/mod.rs

@@ -183,7 +183,7 @@ fn compile<'cfg>(
  // We run these targets later, so this is just a no-op for now.
  Job::new_fresh()
  } else if build_plan {
- Job::new_dirty(rustc(cx, unit, &exec.clone())?, None)
+ Job::new_dirty(rustc(cx, unit, &exec.clone())?, DirtyReason::FreshBuild)
  } else {
  let force = exec.force_rebuild(unit) || force_rebuild;
  let mut job = fingerprint::prepare_target(cx, unit, force)?;

src/cargo/ops/common_for_install_and_uninstall.rs

@@ -175,7 +175,7 @@ impl InstallTracker {
  // Check if any tracked exe's are already installed.
  let duplicates = self.find_duplicates(dst, &exes);
  if force || duplicates.is_empty() {
- return Ok((Freshness::Dirty(Some(DirtyReason::Forced)), duplicates));
+ return Ok((Freshness::Dirty(DirtyReason::Forced), duplicates));
  }
  // Check if all duplicates come from packages of the same name. If
  // there are duplicates from other packages, then --force will be
@@ -205,7 +205,7 @@ impl InstallTracker {
  let source_id = pkg.package_id().source_id();
  if source_id.is_path() {
  // `cargo install --path ...` is always rebuilt.
- return Ok((Freshness::Dirty(Some(DirtyReason::Forced)), duplicates));
+ return Ok((Freshness::Dirty(DirtyReason::Forced), duplicates));
  }
  let is_up_to_date = |dupe_pkg_id| {
  let info = self
@@ -229,7 +229,7 @@ impl InstallTracker {
  if matching_duplicates.iter().all(is_up_to_date) {
  Ok((Freshness::Fresh, duplicates))
  } else {
- Ok((Freshness::Dirty(Some(DirtyReason::Forced)), duplicates))
+ Ok((Freshness::Dirty(DirtyReason::Forced), duplicates))
  }
  } else {
  // Format the error message.