diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index d7f6fa347becb..2b0b65797608b 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -24,7 +24,6 @@ use crate::externalfiles::ExternalHtml;
 use crate::html::markdown::IdMap;
 use crate::html::render::StylePath;
 use crate::html::static_files;
-use crate::passes::{self, Condition};
 use crate::scrape_examples::{AllCallLocations, ScrapeExamplesOptions};
 use crate::{html, opts, theme};
 
@@ -422,38 +421,6 @@ impl Options {
         // check for deprecated options
         check_deprecated_options(matches, dcx);
 
-        if matches.opt_strs("passes") == ["list"] {
-            println!("Available passes for running rustdoc:");
-            for pass in passes::PASSES {
-                println!("{:>20} - {}", pass.name, pass.description);
-            }
-            println!("\nDefault passes for rustdoc:");
-            for p in passes::DEFAULT_PASSES {
-                print!("{:>20}", p.pass.name);
-                println_condition(p.condition);
-            }
-
-            if nightly_options::match_is_nightly_build(matches) {
-                println!("\nPasses run with `--show-coverage`:");
-                for p in passes::COVERAGE_PASSES {
-                    print!("{:>20}", p.pass.name);
-                    println_condition(p.condition);
-                }
-            }
-
-            fn println_condition(condition: Condition) {
-                use Condition::*;
-                match condition {
-                    Always => println!(),
-                    WhenDocumentPrivate => println!("  (when --document-private-items)"),
-                    WhenNotDocumentPrivate => println!("  (when not --document-private-items)"),
-                    WhenNotDocumentHidden => println!("  (when not --document-hidden-items)"),
-                }
-            }
-
-            return None;
-        }
-
         let mut emit = FxIndexMap::<_, EmitType>::default();
         for list in matches.opt_strs("emit") {
             for kind in list.split(',') {
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index b8aaafcb517a9..99f1656d37088 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -33,7 +33,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> {
@@ -421,38 +420,39 @@ 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.render_options.document_private,
-            WhenNotDocumentPrivate => !ctxt.render_options.document_private,
-            WhenNotDocumentHidden => !ctxt.render_options.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");
+
+    let mut visited_links = FxHashMap::default();
+    let mut ambiguous_links = FxIndexMap::default();
+
+    if !show_coverage {
+        krate = passes::track!(tcx, collect_trait_impls(krate, &mut ctxt));
+        krate = passes::track!(tcx, check_doc_test_visibility(krate, &mut ctxt));
+        krate = passes::track!(tcx, check_doc_cfg(krate, &mut ctxt));
+        krate = passes::track!(tcx, strip_aliased_non_local(krate, &mut ctxt));
+    }
+
+    krate = passes::track!(tcx, strip_hidden(krate, &mut ctxt));
+    krate = passes::track!(tcx, strip_private(krate, &mut ctxt));
+
+    if show_coverage {
+        krate = passes::track!(tcx, calculate_doc_coverage(krate, &mut ctxt));
+    }
+
+    if !show_coverage {
+        krate = passes::track!(tcx, strip_priv_imports(krate, &mut ctxt));
+        (krate, LinkCollector { visited_links, ambiguous_links, .. }) =
+            passes::track!(tcx, collect_intra_doc_links(krate, &mut ctxt));
+        krate = passes::track!(tcx, propagate_doc_cfg(krate, &mut ctxt));
+        krate = passes::track!(tcx, propagate_stability(krate, &mut ctxt));
+        krate = passes::track!(tcx, lint(krate, &mut ctxt));
     }
 
     tcx.sess.time("check_lint_expectations", || tcx.check_expectations(Some(sym::rustdoc)));
 
     krate = tcx.sess.time("create_format_cache", || Cache::populate(&mut ctxt, krate));
 
-    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();
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 9871066b9eb51..7ddadbf24d481 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -9,6 +9,7 @@
 #![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(debug_closure_helpers)]
+#![feature(decl_macro)]
 #![feature(file_buffered)]
 #![feature(if_let_guard)]
 #![feature(iter_advance_by)]
@@ -218,7 +219,7 @@ fn init_logging(early_dcx: &EarlyDiagCtxt) {
         .with_ansi(color_logs)
         .with_targets(true)
         .with_wraparound(10)
-        .with_verbose_exit(true)
+        .with_verbose_exit(false)
         .with_verbose_entry(true)
         .with_indent_amount(2);
     #[cfg(debug_assertions)]
diff --git a/src/librustdoc/passes/calculate_doc_coverage.rs b/src/librustdoc/passes/calculate_doc_coverage.rs
index 66d8b667a4cad..c9f41e407efc8 100644
--- a/src/librustdoc/passes/calculate_doc_coverage.rs
+++ b/src/librustdoc/passes/calculate_doc_coverage.rs
@@ -14,17 +14,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),
-    description: "counts the number of items with and without documentation",
-};
-
-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);
 
diff --git a/src/librustdoc/passes/check_doc_cfg.rs b/src/librustdoc/passes/check_doc_cfg.rs
index 3284da77a0222..e9bd85d954858 100644
--- a/src/librustdoc/passes/check_doc_cfg.rs
+++ b/src/librustdoc/passes/check_doc_cfg.rs
@@ -3,17 +3,10 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::sym;
 
-use super::Pass;
 use crate::clean::{Attributes, Crate, Item};
 use crate::core::DocContext;
 use crate::visit::DocVisitor;
 
-pub(crate) const CHECK_DOC_CFG: Pass = Pass {
-    name: "check-doc-cfg",
-    run: Some(check_doc_cfg),
-    description: "checks `#[doc(cfg(...))]` for stability feature and unexpected cfgs",
-};
-
 pub(crate) fn check_doc_cfg(krate: Crate, cx: &mut DocContext<'_>) -> Crate {
     let mut checker = DocCfgChecker { cx };
     checker.visit_crate(&krate);
diff --git a/src/librustdoc/passes/check_doc_test_visibility.rs b/src/librustdoc/passes/check_doc_test_visibility.rs
index e0ea760cf3ba5..ed1dcf05f23d9 100644
--- a/src/librustdoc/passes/check_doc_test_visibility.rs
+++ b/src/librustdoc/passes/check_doc_test_visibility.rs
@@ -10,20 +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),
-    description: "run various visibility-related lints on doctests",
-};
-
 struct DocTestVisibilityLinter<'a, 'tcx> {
     cx: &'a mut DocContext<'tcx>,
 }
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 719b7c6ab89c4..823af04b4d326 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/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, description: "resolves intra-doc links" };
-
 pub(crate) fn collect_intra_doc_links<'a, 'tcx>(
     krate: Crate,
     cx: &'a mut DocContext<'tcx>,
diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs
index 2339a6b69cd8a..8db4b786f7be9 100644
--- a/src/librustdoc/passes/collect_trait_impls.rs
+++ b/src/librustdoc/passes/collect_trait_impls.rs
@@ -8,18 +8,11 @@ use rustc_middle::ty;
 use rustc_span::symbol::sym;
 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),
-    description: "retrieves trait impls for items in the crate",
-};
-
 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
diff --git a/src/librustdoc/passes/lint.rs b/src/librustdoc/passes/lint.rs
index 7740d14148bf0..1cc64c7cbc3b8 100644
--- a/src/librustdoc/passes/lint.rs
+++ b/src/librustdoc/passes/lint.rs
@@ -7,19 +7,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), description: "runs some of rustdoc's 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
 }
diff --git a/src/librustdoc/passes/mod.rs b/src/librustdoc/passes/mod.rs
index 475d05b7d0e76..5742b3cef5f35 100644
--- a/src/librustdoc/passes/mod.rs
+++ b/src/librustdoc/passes/mod.rs
@@ -1,127 +1,23 @@
 //! Contains information about "passes", used to modify crate information during the documentation
 //! process.
 
-use self::Condition::*;
-use crate::clean;
-use crate::core::DocContext;
-
 mod stripper;
 pub(crate) use stripper::*;
 
-mod strip_aliased_non_local;
-pub(crate) use self::strip_aliased_non_local::STRIP_ALIASED_NON_LOCAL;
-
-mod strip_hidden;
-pub(crate) use self::strip_hidden::STRIP_HIDDEN;
-
-mod strip_private;
-pub(crate) use self::strip_private::STRIP_PRIVATE;
-
-mod strip_priv_imports;
-pub(crate) use self::strip_priv_imports::STRIP_PRIV_IMPORTS;
-
-mod propagate_doc_cfg;
-pub(crate) use self::propagate_doc_cfg::PROPAGATE_DOC_CFG;
-
-mod propagate_stability;
-pub(crate) use self::propagate_stability::PROPAGATE_STABILITY;
-
+pub(crate) mod calculate_doc_coverage;
+pub(crate) mod check_doc_cfg;
+pub(crate) mod check_doc_test_visibility;
 pub(crate) mod collect_intra_doc_links;
-pub(crate) use self::collect_intra_doc_links::COLLECT_INTRA_DOC_LINKS;
-
-mod check_doc_test_visibility;
-pub(crate) use self::check_doc_test_visibility::CHECK_DOC_TEST_VISIBILITY;
-
-mod check_doc_cfg;
-pub(crate) use self::check_doc_cfg::CHECK_DOC_CFG;
-
-mod collect_trait_impls;
-pub(crate) use self::collect_trait_impls::COLLECT_TRAIT_IMPLS;
-
-mod calculate_doc_coverage;
-pub(crate) use self::calculate_doc_coverage::CALCULATE_DOC_COVERAGE;
-
-mod lint;
-pub(crate) use self::lint::RUN_LINTS;
-
-/// 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>,
-    pub(crate) description: &'static str,
-}
-
-/// 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,
-}
-
-/// The full list of passes.
-pub(crate) const PASSES: &[Pass] = &[
-    CHECK_DOC_CFG,
-    CHECK_DOC_TEST_VISIBILITY,
-    STRIP_ALIASED_NON_LOCAL,
-    STRIP_HIDDEN,
-    STRIP_PRIVATE,
-    STRIP_PRIV_IMPORTS,
-    PROPAGATE_DOC_CFG,
-    PROPAGATE_STABILITY,
-    COLLECT_INTRA_DOC_LINKS,
-    COLLECT_TRAIT_IMPLS,
-    CALCULATE_DOC_COVERAGE,
-    RUN_LINTS,
-];
-
-/// The list of passes run by default.
-pub(crate) const DEFAULT_PASSES: &[ConditionalPass] = &[
-    ConditionalPass::always(COLLECT_TRAIT_IMPLS),
-    ConditionalPass::always(CHECK_DOC_TEST_VISIBILITY),
-    ConditionalPass::always(CHECK_DOC_CFG),
-    ConditionalPass::always(STRIP_ALIASED_NON_LOCAL),
-    ConditionalPass::new(STRIP_HIDDEN, WhenNotDocumentHidden),
-    ConditionalPass::new(STRIP_PRIVATE, WhenNotDocumentPrivate),
-    ConditionalPass::new(STRIP_PRIV_IMPORTS, WhenDocumentPrivate),
-    ConditionalPass::always(COLLECT_INTRA_DOC_LINKS),
-    ConditionalPass::always(PROPAGATE_DOC_CFG),
-    ConditionalPass::always(PROPAGATE_STABILITY),
-    ConditionalPass::always(RUN_LINTS),
-];
-
-/// The list of default passes run when `--doc-coverage` is passed to rustdoc.
-pub(crate) const COVERAGE_PASSES: &[ConditionalPass] = &[
-    ConditionalPass::new(STRIP_HIDDEN, WhenNotDocumentHidden),
-    ConditionalPass::new(STRIP_PRIVATE, WhenNotDocumentPrivate),
-    ConditionalPass::always(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) 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;
+
+pub(crate) macro track($tcx:expr, $name:ident($( $args:tt )*)) {{
+    tracing::debug!("running pass `{}`", stringify!($name));
+    $tcx.sess.time(stringify!($name), || self::$name::$name($( $args )*))
+}}
diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs
index eddafa9ba8e49..0d28b93ae07c4 100644
--- a/src/librustdoc/passes/propagate_doc_cfg.rs
+++ b/src/librustdoc/passes/propagate_doc_cfg.rs
@@ -9,13 +9,6 @@ use crate::clean::inline::{load_attrs, merge_attrs};
 use crate::clean::{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),
-    description: "propagates `#[doc(cfg(...))]` to child items",
-};
 
 pub(crate) fn propagate_doc_cfg(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
     CfgPropagator { parent_cfg: None, parent: None, cx }.fold_crate(cr)
diff --git a/src/librustdoc/passes/propagate_stability.rs b/src/librustdoc/passes/propagate_stability.rs
index 5139ca301dd3d..02b9cf85a9bb8 100644
--- a/src/librustdoc/passes/propagate_stability.rs
+++ b/src/librustdoc/passes/propagate_stability.rs
@@ -12,13 +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),
-    description: "propagates stability to child items",
-};
 
 pub(crate) fn propagate_stability(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
     let crate_stability = cx.tcx.lookup_stability(CRATE_DEF_ID);
diff --git a/src/librustdoc/passes/strip_aliased_non_local.rs b/src/librustdoc/passes/strip_aliased_non_local.rs
index bb13308e6c2a9..265d7f00539cf 100644
--- a/src/librustdoc/passes/strip_aliased_non_local.rs
+++ b/src/librustdoc/passes/strip_aliased_non_local.rs
@@ -4,15 +4,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),
-    description: "strips all non-local private aliased items from the output",
-};
-
-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)
 }
diff --git a/src/librustdoc/passes/strip_hidden.rs b/src/librustdoc/passes/strip_hidden.rs
index 3388ae46f056c..39e3ed5dccbd0 100644
--- a/src/librustdoc/passes/strip_hidden.rs
+++ b/src/librustdoc/passes/strip_hidden.rs
@@ -11,16 +11,14 @@ use crate::clean::utils::inherits_doc_hidden;
 use crate::clean::{self, Item, ItemIdSet, reexport_chain};
 use crate::core::DocContext;
 use crate::fold::{DocFolder, strip_item};
-use crate::passes::{ImplStripper, Pass};
-
-pub(crate) const STRIP_HIDDEN: Pass = Pass {
-    name: "strip-hidden",
-    run: Some(strip_hidden),
-    description: "strips all `#[doc(hidden)]` items from the output",
-};
+use crate::passes::ImplStripper;
 
 /// Strip items marked `#[doc(hidden)]`
 pub(crate) fn strip_hidden(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate {
+    if cx.render_options.document_hidden {
+        return krate;
+    }
+
     let mut retained = ItemIdSet::default();
     let is_json_output = cx.is_json_output();
 
diff --git a/src/librustdoc/passes/strip_priv_imports.rs b/src/librustdoc/passes/strip_priv_imports.rs
index b9b2431f06f2b..dc50055b0f6e7 100644
--- a/src/librustdoc/passes/strip_priv_imports.rs
+++ b/src/librustdoc/passes/strip_priv_imports.rs
@@ -4,15 +4,13 @@
 use crate::clean;
 use crate::core::DocContext;
 use crate::fold::DocFolder;
-use crate::passes::{ImportStripper, Pass};
-
-pub(crate) const STRIP_PRIV_IMPORTS: Pass = Pass {
-    name: "strip-priv-imports",
-    run: Some(strip_priv_imports),
-    description: "strips all private import statements (`use`, `extern crate`) from a crate",
-};
+use crate::passes::ImportStripper;
 
 pub(crate) fn strip_priv_imports(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate {
+    if !cx.render_options.document_private {
+        return krate;
+    }
+
     let is_json_output = cx.is_json_output();
     ImportStripper {
         tcx: cx.tcx,
diff --git a/src/librustdoc/passes/strip_private.rs b/src/librustdoc/passes/strip_private.rs
index 1bd8a7838ec08..a47b7bd5bb2ef 100644
--- a/src/librustdoc/passes/strip_private.rs
+++ b/src/librustdoc/passes/strip_private.rs
@@ -4,18 +4,15 @@
 use crate::clean::{self, ItemIdSet};
 use crate::core::DocContext;
 use crate::fold::DocFolder;
-use crate::passes::{ImplStripper, ImportStripper, Pass, Stripper};
-
-pub(crate) const STRIP_PRIVATE: Pass = Pass {
-    name: "strip-private",
-    run: Some(strip_private),
-    description: "strips all private items from a crate which cannot be seen externally, \
-                  implies strip-priv-imports",
-};
+use crate::passes::{ImplStripper, ImportStripper, Stripper};
 
 /// Strip private items from the point of view of a crate or externally from a
 /// crate, specified by the `xcrate` flag.
 pub(crate) fn strip_private(mut krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate {
+    if cx.render_options.document_private {
+        return krate;
+    }
+
     // This stripper collects all *retained* nodes.
     let mut retained = ItemIdSet::default();
     let is_json_output = cx.is_json_output();
diff --git a/tests/rustdoc-ui/issues/issue-91713.stdout b/tests/rustdoc-ui/issues/issue-91713.stdout
deleted file mode 100644
index 30aadfe89f424..0000000000000
--- a/tests/rustdoc-ui/issues/issue-91713.stdout
+++ /dev/null
@@ -1,31 +0,0 @@
-Available passes for running rustdoc:
-       check-doc-cfg - checks `#[doc(cfg(...))]` for stability feature and unexpected cfgs
-check_doc_test_visibility - run various visibility-related lints on doctests
-strip-aliased-non-local - strips all non-local private aliased items from the output
-        strip-hidden - strips all `#[doc(hidden)]` items from the output
-       strip-private - strips all private items from a crate which cannot be seen externally, implies strip-priv-imports
-  strip-priv-imports - strips all private import statements (`use`, `extern crate`) from a crate
-   propagate-doc-cfg - propagates `#[doc(cfg(...))]` to child items
- propagate-stability - propagates stability to child items
-collect-intra-doc-links - resolves intra-doc links
- collect-trait-impls - retrieves trait impls for items in the crate
-calculate-doc-coverage - counts the number of items with and without documentation
-           run-lints - runs some of rustdoc's lints
-
-Default passes for rustdoc:
- collect-trait-impls
-check_doc_test_visibility
-       check-doc-cfg
-strip-aliased-non-local
-        strip-hidden  (when not --document-hidden-items)
-       strip-private  (when not --document-private-items)
-  strip-priv-imports  (when --document-private-items)
-collect-intra-doc-links
-   propagate-doc-cfg
- propagate-stability
-           run-lints
-
-Passes run with `--show-coverage`:
-        strip-hidden  (when not --document-hidden-items)
-       strip-private  (when not --document-private-items)
-calculate-doc-coverage