rustdoc: Defossilize the passes infrastructure

Author: fmease

src/librustdoc/core.rs

@@ -32,7 +32,6 @@ use crate::config::{Options as RustdocOptions, OutputFormat, RenderOptions};
 use crate::formats::cache::Cache;
 use crate::html::macro_expansion::{ExpandedCode, source_macro_expansion};
 use crate::passes;
-use crate::passes::Condition::*;
 use crate::passes::collect_intra_doc_links::LinkCollector;
 
 pub(crate) struct DocContext<'tcx> {
@@ -412,39 +411,38 @@ pub(crate) fn run_global_ctxt(
         );
     }
 
-    info!("Executing passes");
-
-    let mut visited = FxHashMap::default();
-    let mut ambiguous = FxIndexMap::default();
-
-    for p in passes::defaults(show_coverage) {
-        let run = match p.condition {
-            Always => true,
-            WhenDocumentPrivate => ctxt.document_private(),
-            WhenNotDocumentPrivate => !ctxt.document_private(),
-            WhenNotDocumentHidden => !ctxt.document_hidden(),
-        };
-        if run {
-            debug!("running pass {}", p.pass.name);
-            if let Some(run_fn) = p.pass.run {
-                krate = tcx.sess.time(p.pass.name, || run_fn(krate, &mut ctxt));
-            } else {
-                let (k, LinkCollector { visited_links, ambiguous_links, .. }) =
-                    passes::collect_intra_doc_links::collect_intra_doc_links(krate, &mut ctxt);
-                krate = k;
-                visited = visited_links;
-                ambiguous = ambiguous_links;
-            }
-        }
+    info!("running passes");
+    passes::initialize!(tcx, ctxt);
+
+    let mut visited_links = FxHashMap::default();
+    let mut ambiguous_links = FxIndexMap::default();
+
+    if !show_coverage {
+        krate = track!(collect_trait_impls(krate));
+        krate = track!(check_doc_test_visibility(krate));
+        krate = track!(strip_aliased_non_local(krate));
+        krate = track!(propagate_doc_cfg(krate));
+    }
+
+    krate = track!(strip_hidden(krate));
+    krate = track!(strip_private(krate));
+
+    if show_coverage {
+        krate = track!(calculate_doc_coverage(krate));
+    } else {
+        krate = track!(strip_priv_imports(krate));
+        (krate, LinkCollector { visited_links, ambiguous_links, .. }) =
+            track!(collect_intra_doc_links(krate));
+        krate = track!(propagate_stability(krate));
+        krate = track!(lint(krate));
     }
 
     tcx.sess.time("check_lint_expectations", || tcx.check_expectations(Some(sym::rustdoc)));
 
     krate =
         tcx.sess.time("create_format_cache", || Cache::populate(&mut ctxt, krate, &render_options));
 
-    let mut collector =
-        LinkCollector { cx: &mut ctxt, visited_links: visited, ambiguous_links: ambiguous };
+    let mut collector = LinkCollector { cx: &mut ctxt, visited_links, ambiguous_links };
     collector.resolve_ambiguities();
 
     tcx.dcx().abort_if_errors();

src/librustdoc/passes/calculate_doc_coverage.rs

@@ -17,14 +17,13 @@ use tracing::debug;
 use crate::clean;
 use crate::core::DocContext;
 use crate::html::markdown::{ErrorCodes, find_testable_code};
-use crate::passes::Pass;
 use crate::passes::check_doc_test_visibility::{Tests, should_have_doc_example};
 use crate::visit::DocVisitor;
 
-pub(crate) const CALCULATE_DOC_COVERAGE: Pass =
-    Pass { name: "calculate-doc-coverage", run: Some(calculate_doc_coverage) };
-
-fn calculate_doc_coverage(krate: clean::Crate, ctx: &mut DocContext<'_>) -> clean::Crate {
+pub(crate) fn calculate_doc_coverage(
+    krate: clean::Crate,
+    ctx: &mut DocContext<'_>,
+) -> clean::Crate {
     let mut calc = CoverageCalculator { items: Default::default(), ctx };
     calc.visit_crate(&krate);
 

src/librustdoc/passes/check_doc_test_visibility.rs

@@ -10,17 +10,12 @@ use rustc_middle::lint::{LevelAndSource, LintLevelSource};
 use rustc_session::lint;
 use tracing::debug;
 
-use super::Pass;
-use crate::clean;
 use crate::clean::utils::inherits_doc_hidden;
-use crate::clean::*;
+use crate::clean::{self, *};
 use crate::core::DocContext;
 use crate::html::markdown::{ErrorCodes, Ignore, LangString, MdRelLine, find_testable_code};
 use crate::visit::DocVisitor;
 
-pub(crate) const CHECK_DOC_TEST_VISIBILITY: Pass =
-    Pass { name: "check_doc_test_visibility", run: Some(check_doc_test_visibility) };
-
 struct DocTestVisibilityLinter<'a, 'tcx> {
     cx: &'a mut DocContext<'tcx>,
 }

src/librustdoc/passes/collect_intra_doc_links.rs

@@ -34,12 +34,8 @@ use crate::clean::{self, Crate, Item, ItemId, ItemLink, PrimitiveType};
 use crate::core::DocContext;
 use crate::html::markdown::{MarkdownLink, MarkdownLinkRange, markdown_links};
 use crate::lint::{BROKEN_INTRA_DOC_LINKS, PRIVATE_INTRA_DOC_LINKS};
-use crate::passes::Pass;
 use crate::visit::DocVisitor;
 
-pub(crate) const COLLECT_INTRA_DOC_LINKS: Pass =
-    Pass { name: "collect-intra-doc-links", run: None };
-
 pub(crate) fn collect_intra_doc_links<'a, 'tcx>(
     krate: Crate,
     cx: &'a mut DocContext<'tcx>,

src/librustdoc/passes/collect_trait_impls.rs

@@ -10,15 +10,11 @@ use rustc_hir::def_id::{DefId, DefIdMap, DefIdSet, LOCAL_CRATE};
 use rustc_middle::ty;
 use tracing::debug;
 
-use super::Pass;
 use crate::clean::*;
 use crate::core::DocContext;
 use crate::formats::cache::Cache;
 use crate::visit::DocVisitor;
 
-pub(crate) const COLLECT_TRAIT_IMPLS: Pass =
-    Pass { name: "collect-trait-impls", run: Some(collect_trait_impls) };
-
 pub(crate) fn collect_trait_impls(mut krate: Crate, cx: &mut DocContext<'_>) -> Crate {
     let tcx = cx.tcx;
     // We need to check if there are errors before running this pass because it would crash when

src/librustdoc/passes/lint.rs

@@ -6,18 +6,15 @@ mod html_tags;
 mod redundant_explicit_links;
 mod unescaped_backticks;
 
-use super::Pass;
 use crate::clean::*;
 use crate::core::DocContext;
 use crate::visit::DocVisitor;
 
-pub(crate) const RUN_LINTS: Pass = Pass { name: "run-lints", run: Some(run_lints) };
-
 struct Linter<'a, 'tcx> {
     cx: &'a mut DocContext<'tcx>,
 }
 
-pub(crate) fn run_lints(krate: Crate, cx: &mut DocContext<'_>) -> Crate {
+pub(crate) fn lint(krate: Crate, cx: &mut DocContext<'_>) -> Crate {
     Linter { cx }.visit_crate(&krate);
     krate
 }

src/librustdoc/passes/mod.rs

@@ -1,85 +1,29 @@
-//! Contains information about "passes", used to modify crate information during the documentation
-//! process.
-
-use self::Condition::*;
-use crate::clean;
-use crate::core::DocContext;
+//! The definitions of *passes* which transform crate information.
 
 mod stripper;
 pub(crate) use stripper::*;
 
-mod calculate_doc_coverage;
-mod check_doc_test_visibility;
+pub(crate) mod calculate_doc_coverage;
+pub(crate) mod check_doc_test_visibility;
 pub(crate) mod collect_intra_doc_links;
-mod collect_trait_impls;
-mod lint;
-mod propagate_doc_cfg;
-mod propagate_stability;
-mod strip_aliased_non_local;
-mod strip_hidden;
-mod strip_priv_imports;
-mod strip_private;
-
-/// A single pass over the cleaned documentation.
-///
-/// Runs in the compiler context, so it has access to types and traits and the like.
-#[derive(Copy, Clone)]
-pub(crate) struct Pass {
-    pub(crate) name: &'static str,
-    pub(crate) run: Option<fn(clean::Crate, &mut DocContext<'_>) -> clean::Crate>,
-}
-
-/// In a list of passes, a pass that may or may not need to be run depending on options.
-#[derive(Copy, Clone)]
-pub(crate) struct ConditionalPass {
-    pub(crate) pass: Pass,
-    pub(crate) condition: Condition,
-}
-
-/// How to decide whether to run a conditional pass.
-#[derive(Copy, Clone)]
-pub(crate) enum Condition {
-    Always,
-    /// When `--document-private-items` is passed.
-    WhenDocumentPrivate,
-    /// When `--document-private-items` is not passed.
-    WhenNotDocumentPrivate,
-    /// When `--document-hidden-items` is not passed.
-    WhenNotDocumentHidden,
+pub(crate) mod collect_trait_impls;
+pub(crate) mod lint;
+pub(crate) mod propagate_doc_cfg;
+pub(crate) mod propagate_stability;
+pub(crate) mod strip_aliased_non_local;
+pub(crate) mod strip_hidden;
+pub(crate) mod strip_priv_imports;
+pub(crate) mod strip_private;
+
+macro_rules! initialize {
+    ($tcx:ident, $cx:ident) => {
+        macro_rules! track {
+            ($name:ident($krate:ident)) => {{
+                debug!("running pass `{}`", stringify!($name));
+                $tcx.sess.time(stringify!($name), || passes::$name::$name($krate, &mut $cx))
+            }};
+        }
+    };
 }
 
-/// The list of passes run by default.
-const DEFAULT_PASSES: &[ConditionalPass] = &[
-    ConditionalPass::always(collect_trait_impls::COLLECT_TRAIT_IMPLS),
-    ConditionalPass::always(check_doc_test_visibility::CHECK_DOC_TEST_VISIBILITY),
-    ConditionalPass::always(strip_aliased_non_local::STRIP_ALIASED_NON_LOCAL),
-    ConditionalPass::always(propagate_doc_cfg::PROPAGATE_DOC_CFG),
-    ConditionalPass::new(strip_hidden::STRIP_HIDDEN, WhenNotDocumentHidden),
-    ConditionalPass::new(strip_private::STRIP_PRIVATE, WhenNotDocumentPrivate),
-    ConditionalPass::new(strip_priv_imports::STRIP_PRIV_IMPORTS, WhenDocumentPrivate),
-    ConditionalPass::always(collect_intra_doc_links::COLLECT_INTRA_DOC_LINKS),
-    ConditionalPass::always(propagate_stability::PROPAGATE_STABILITY),
-    ConditionalPass::always(lint::RUN_LINTS),
-];
-
-/// The list of default passes run when `--doc-coverage` is passed to rustdoc.
-const COVERAGE_PASSES: &[ConditionalPass] = &[
-    ConditionalPass::new(strip_hidden::STRIP_HIDDEN, WhenNotDocumentHidden),
-    ConditionalPass::new(strip_private::STRIP_PRIVATE, WhenNotDocumentPrivate),
-    ConditionalPass::always(calculate_doc_coverage::CALCULATE_DOC_COVERAGE),
-];
-
-impl ConditionalPass {
-    pub(crate) const fn always(pass: Pass) -> Self {
-        Self::new(pass, Always)
-    }
-
-    pub(crate) const fn new(pass: Pass, condition: Condition) -> Self {
-        ConditionalPass { pass, condition }
-    }
-}
-
-/// Returns the given default set of passes.
-pub(crate) fn defaults(show_coverage: bool) -> &'static [ConditionalPass] {
-    if show_coverage { COVERAGE_PASSES } else { DEFAULT_PASSES }
-}
+pub(crate) use initialize;

src/librustdoc/passes/propagate_doc_cfg.rs

@@ -10,10 +10,6 @@ use crate::clean::inline::{load_attrs, merge_attrs};
 use crate::clean::{CfgInfo, Crate, Item, ItemKind};
 use crate::core::DocContext;
 use crate::fold::DocFolder;
-use crate::passes::Pass;
-
-pub(crate) const PROPAGATE_DOC_CFG: Pass =
-    Pass { name: "propagate-doc-cfg", run: Some(propagate_doc_cfg) };
 
 pub(crate) fn propagate_doc_cfg(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
     if cx.tcx.features().doc_cfg() {

src/librustdoc/passes/propagate_stability.rs

@@ -12,10 +12,6 @@ use rustc_hir::{Stability, StabilityLevel};
 use crate::clean::{Crate, Item, ItemId, ItemKind};
 use crate::core::DocContext;
 use crate::fold::DocFolder;
-use crate::passes::Pass;
-
-pub(crate) const PROPAGATE_STABILITY: Pass =
-    Pass { name: "propagate-stability", run: Some(propagate_stability) };
 
 pub(crate) fn propagate_stability(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
     let crate_stability = cx.tcx.lookup_stability(CRATE_DEF_ID);

src/librustdoc/passes/strip_aliased_non_local.rs

@@ -6,12 +6,11 @@ use crate::clean;
 use crate::clean::Item;
 use crate::core::DocContext;
 use crate::fold::{DocFolder, strip_item};
-use crate::passes::Pass;
 
-pub(crate) const STRIP_ALIASED_NON_LOCAL: Pass =
-    Pass { name: "strip-aliased-non-local", run: Some(strip_aliased_non_local) };
-
-fn strip_aliased_non_local(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate {
+pub(crate) fn strip_aliased_non_local(
+    krate: clean::Crate,
+    cx: &mut DocContext<'_>,
+) -> clean::Crate {
     let mut stripper = AliasedNonLocalStripper { tcx: cx.tcx };
     stripper.fold_crate(krate)
 }