refactor: move RustDocFingerprint to fingerprint mod

Author: weihanglo

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

@@ -13,9 +13,10 @@ use crate::util::logger::BuildLogger;
 use std::collections::{HashMap, HashSet};
 
 mod target_info;
-pub use self::target_info::{
-    FileFlavor, FileType, RustDocFingerprint, RustcTargetData, TargetInfo,
-};
+pub use self::target_info::FileFlavor;
+pub use self::target_info::FileType;
+pub use self::target_info::RustcTargetData;
+pub use self::target_info::TargetInfo;
 
 /// The build context, containing complete information needed for a build task
 /// before it gets started.

src/cargo/core/compiler/build_context/target_info.rs

@@ -7,19 +7,24 @@
 //! * [`RustcTargetData::info`] to get a [`TargetInfo`] for an in-depth query.
 //! * [`TargetInfo::rustc_outputs`] to get a list of supported file types.
 
+use crate::core::compiler::CompileKind;
+use crate::core::compiler::CompileMode;
+use crate::core::compiler::CompileTarget;
+use crate::core::compiler::CrateType;
 use crate::core::compiler::apply_env_config;
-use crate::core::compiler::{BuildRunner, CompileKind, CompileMode, CompileTarget, CrateType};
 use crate::core::{Dependency, Package, Target, TargetKind, Workspace};
 use crate::util::context::{GlobalContext, StringList, TargetConfig};
 use crate::util::interning::InternedString;
 use crate::util::{CargoResult, Rustc};
+
 use anyhow::Context as _;
 use cargo_platform::{Cfg, CfgExpr};
-use cargo_util::{ProcessBuilder, paths};
-use serde::{Deserialize, Serialize};
+use cargo_util::ProcessBuilder;
+use serde::Deserialize;
+
 use std::cell::RefCell;
 use std::collections::hash_map::{Entry, HashMap};
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::rc::Rc;
 use std::str::{self, FromStr};
 
@@ -1110,113 +1115,3 @@ impl<'gctx> RustcTargetData<'gctx> {
         &self.requested_kinds
     }
 }
-
-/// Structure used to deal with Rustdoc fingerprinting
-#[derive(Debug, Serialize, Deserialize)]
-pub struct RustDocFingerprint {
-    pub rustc_vv: String,
-}
-
-impl RustDocFingerprint {
-    /// This function checks whether the latest version of `Rustc` used to compile this
-    /// `Workspace`'s docs was the same as the one is currently being used in this `cargo doc`
-    /// call.
-    ///
-    /// In case it's not, it takes care of removing the `doc/` folder as well as overwriting
-    /// the rustdoc fingerprint info in order to guarantee that we won't end up with mixed
-    /// versions of the `js/html/css` files that `rustdoc` autogenerates which do not have
-    /// any versioning.
-    pub fn check_rustdoc_fingerprint(build_runner: &BuildRunner<'_, '_>) -> CargoResult<()> {
-        if build_runner
-            .bcx
-            .gctx
-            .cli_unstable()
-            .skip_rustdoc_fingerprint
-        {
-            return Ok(());
-        }
-        let actual_rustdoc_target_data = RustDocFingerprint {
-            rustc_vv: build_runner.bcx.rustc().verbose_version.clone(),
-        };
-
-        let fingerprint_path = build_runner
-            .files()
-            .host_build_root()
-            .join(".rustdoc_fingerprint.json");
-        let write_fingerprint = || -> CargoResult<()> {
-            paths::write(
-                &fingerprint_path,
-                serde_json::to_string(&actual_rustdoc_target_data)?,
-            )
-        };
-        let Ok(rustdoc_data) = paths::read(&fingerprint_path) else {
-            // If the fingerprint does not exist, do not clear out the doc
-            // directories. Otherwise this ran into problems where projects
-            // like bootstrap were creating the doc directory before running
-            // `cargo doc` in a way that deleting it would break it.
-            return write_fingerprint();
-        };
-        match serde_json::from_str::<RustDocFingerprint>(&rustdoc_data) {
-            Ok(fingerprint) => {
-                if fingerprint.rustc_vv == actual_rustdoc_target_data.rustc_vv {
-                    return Ok(());
-                } else {
-                    tracing::debug!(
-                        "doc fingerprint changed:\noriginal:\n{}\nnew:\n{}",
-                        fingerprint.rustc_vv,
-                        actual_rustdoc_target_data.rustc_vv
-                    );
-                }
-            }
-            Err(e) => {
-                tracing::debug!("could not deserialize {:?}: {}", fingerprint_path, e);
-            }
-        };
-        // Fingerprint does not match, delete the doc directories and write a new fingerprint.
-        tracing::debug!(
-            "fingerprint {:?} mismatch, clearing doc directories",
-            fingerprint_path
-        );
-        build_runner
-            .bcx
-            .all_kinds
-            .iter()
-            .map(|kind| {
-                build_runner
-                    .files()
-                    .layout(*kind)
-                    .artifact_dir()
-                    .expect("artifact-dir was not locked")
-                    .doc()
-            })
-            .filter(|path| path.exists())
-            .try_for_each(|path| clean_doc(path))?;
-        write_fingerprint()?;
-        return Ok(());
-
-        fn clean_doc(path: &Path) -> CargoResult<()> {
-            let entries = path
-                .read_dir()
-                .with_context(|| format!("failed to read directory `{}`", path.display()))?;
-            for entry in entries {
-                let entry = entry?;
-                // Don't remove hidden files. Rustdoc does not create them,
-                // but the user might have.
-                if entry
-                    .file_name()
-                    .to_str()
-                    .map_or(false, |name| name.starts_with('.'))
-                {
-                    continue;
-                }
-                let path = entry.path();
-                if entry.file_type()?.is_dir() {
-                    paths::remove_dir_all(path)?;
-                } else {
-                    paths::remove_file(path)?;
-                }
-            }
-            Ok(())
-        }
-    }
-}

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

@@ -371,6 +371,7 @@
 
 mod dep_info;
 mod dirty_reason;
+mod rustdoc;
 
 use std::collections::hash_map::{Entry, HashMap};
 use std::env;
@@ -409,6 +410,7 @@ pub use self::dep_info::parse_dep_info;
 pub use self::dep_info::parse_rustc_dep_info;
 pub use self::dep_info::translate_dep_info;
 pub use self::dirty_reason::DirtyReason;
+pub use self::rustdoc::RustDocFingerprint;
 
 /// Determines if a [`Unit`] is up-to-date, and if not prepares necessary work to
 /// update the persisted fingerprint.

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

@@ -0,0 +1,119 @@
+use std::path::Path;
+
+use anyhow::Context as _;
+use cargo_util::paths;
+use serde::Deserialize;
+use serde::Serialize;
+
+use crate::CargoResult;
+use crate::core::compiler::BuildRunner;
+
+/// Structure used to deal with Rustdoc fingerprinting
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RustDocFingerprint {
+    pub rustc_vv: String,
+}
+
+impl RustDocFingerprint {
+    /// This function checks whether the latest version of `Rustc` used to compile this
+    /// `Workspace`'s docs was the same as the one is currently being used in this `cargo doc`
+    /// call.
+    ///
+    /// In case it's not, it takes care of removing the `doc/` folder as well as overwriting
+    /// the rustdoc fingerprint info in order to guarantee that we won't end up with mixed
+    /// versions of the `js/html/css` files that `rustdoc` autogenerates which do not have
+    /// any versioning.
+    pub fn check_rustdoc_fingerprint(build_runner: &BuildRunner<'_, '_>) -> CargoResult<()> {
+        if build_runner
+            .bcx
+            .gctx
+            .cli_unstable()
+            .skip_rustdoc_fingerprint
+        {
+            return Ok(());
+        }
+        let actual_rustdoc_target_data = RustDocFingerprint {
+            rustc_vv: build_runner.bcx.rustc().verbose_version.clone(),
+        };
+
+        let fingerprint_path = build_runner
+            .files()
+            .host_build_root()
+            .join(".rustdoc_fingerprint.json");
+        let write_fingerprint = || -> CargoResult<()> {
+            paths::write(
+                &fingerprint_path,
+                serde_json::to_string(&actual_rustdoc_target_data)?,
+            )
+        };
+        let Ok(rustdoc_data) = paths::read(&fingerprint_path) else {
+            // If the fingerprint does not exist, do not clear out the doc
+            // directories. Otherwise this ran into problems where projects
+            // like bootstrap were creating the doc directory before running
+            // `cargo doc` in a way that deleting it would break it.
+            return write_fingerprint();
+        };
+        match serde_json::from_str::<RustDocFingerprint>(&rustdoc_data) {
+            Ok(fingerprint) => {
+                if fingerprint.rustc_vv == actual_rustdoc_target_data.rustc_vv {
+                    return Ok(());
+                } else {
+                    tracing::debug!(
+                        "doc fingerprint changed:\noriginal:\n{}\nnew:\n{}",
+                        fingerprint.rustc_vv,
+                        actual_rustdoc_target_data.rustc_vv
+                    );
+                }
+            }
+            Err(e) => {
+                tracing::debug!("could not deserialize {:?}: {}", fingerprint_path, e);
+            }
+        };
+        // Fingerprint does not match, delete the doc directories and write a new fingerprint.
+        tracing::debug!(
+            "fingerprint {:?} mismatch, clearing doc directories",
+            fingerprint_path
+        );
+        build_runner
+            .bcx
+            .all_kinds
+            .iter()
+            .map(|kind| {
+                build_runner
+                    .files()
+                    .layout(*kind)
+                    .artifact_dir()
+                    .expect("artifact-dir was not locked")
+                    .doc()
+            })
+            .filter(|path| path.exists())
+            .try_for_each(|path| clean_doc(path))?;
+        write_fingerprint()?;
+        return Ok(());
+
+        fn clean_doc(path: &Path) -> CargoResult<()> {
+            let entries = path
+                .read_dir()
+                .with_context(|| format!("failed to read directory `{}`", path.display()))?;
+            for entry in entries {
+                let entry = entry?;
+                // Don't remove hidden files. Rustdoc does not create them,
+                // but the user might have.
+                if entry
+                    .file_name()
+                    .to_str()
+                    .map_or(false, |name| name.starts_with('.'))
+                {
+                    continue;
+                }
+                let path = entry.path();
+                if entry.file_type()?.is_dir() {
+                    paths::remove_dir_all(path)?;
+                } else {
+                    paths::remove_file(path)?;
+                }
+            }
+            Ok(())
+        }
+    }
+}

src/cargo/core/compiler/mod.rs

@@ -72,16 +72,19 @@ use tracing::{debug, instrument, trace};
 
 pub use self::build_config::UserIntent;
 pub use self::build_config::{BuildConfig, CompileMode, MessageFormat, TimingOutput};
-pub use self::build_context::{
-    BuildContext, FileFlavor, FileType, RustDocFingerprint, RustcTargetData, TargetInfo,
-};
+pub use self::build_context::BuildContext;
+pub use self::build_context::FileFlavor;
+pub use self::build_context::FileType;
+pub use self::build_context::RustcTargetData;
+pub use self::build_context::TargetInfo;
 pub use self::build_runner::{BuildRunner, Metadata, UnitHash};
 pub use self::compilation::{Compilation, Doctest, UnitOutput};
 pub use self::compile_kind::{CompileKind, CompileKindFallback, CompileTarget};
 pub use self::crate_type::CrateType;
 pub use self::custom_build::LinkArgTarget;
 pub use self::custom_build::{BuildOutput, BuildScriptOutputs, BuildScripts, LibraryPath};
 pub(crate) use self::fingerprint::DirtyReason;
+pub use self::fingerprint::RustDocFingerprint;
 pub use self::job_queue::Freshness;
 use self::job_queue::{Job, JobQueue, JobState, Work};
 pub(crate) use self::layout::Layout;