rustdoc: Nuke --passes=list and defossilize the passes infrastructure

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(',') {

src/librustdoc/passes/calculate_doc_coverage.rs

@@ -18,11 +18,8 @@ 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",
-};
+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 {
     let mut calc = CoverageCalculator { items: Default::default(), ctx };

src/librustdoc/passes/check_doc_cfg.rs

@@ -8,11 +8,7 @@ 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) const CHECK_DOC_CFG: Pass = Pass { name: "check-doc-cfg", run: Some(check_doc_cfg) };
 
 pub(crate) fn check_doc_cfg(krate: Crate, cx: &mut DocContext<'_>) -> Crate {
     let mut checker = DocCfgChecker { cx };

src/librustdoc/passes/check_doc_test_visibility.rs

@@ -18,11 +18,8 @@ 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",
-};
+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

@@ -38,7 +38,7 @@ 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" };
+    Pass { name: "collect-intra-doc-links", run: None };
 
 pub(crate) fn collect_intra_doc_links<'a, 'tcx>(
     krate: Crate,

src/librustdoc/passes/collect_trait_impls.rs

@@ -14,11 +14,8 @@ 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) 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;

src/librustdoc/passes/lint.rs

@@ -12,8 +12,7 @@ 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" };
+pub(crate) const RUN_LINTS: Pass = Pass { name: "run-lints", run: Some(run_lints) };
 
 struct Linter<'a, 'tcx> {
     cx: &'a mut DocContext<'tcx>,

src/librustdoc/passes/mod.rs

@@ -8,41 +8,18 @@ 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 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 calculate_doc_coverage;
 mod check_doc_cfg;
-pub(crate) use self::check_doc_cfg::CHECK_DOC_CFG;
-
+mod check_doc_test_visibility;
+pub(crate) mod collect_intra_doc_links;
 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;
+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.
 ///
@@ -51,7 +28,6 @@ pub(crate) use self::lint::RUN_LINTS;
 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.
@@ -73,42 +49,26 @@ pub(crate) enum Condition {
     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),
+const DEFAULT_PASSES: &[ConditionalPass] = &[
+    ConditionalPass::always(collect_trait_impls::COLLECT_TRAIT_IMPLS),
+    ConditionalPass::always(check_doc_test_visibility::CHECK_DOC_TEST_VISIBILITY),
+    ConditionalPass::always(check_doc_cfg::CHECK_DOC_CFG),
+    ConditionalPass::always(strip_aliased_non_local::STRIP_ALIASED_NON_LOCAL),
+    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_doc_cfg::PROPAGATE_DOC_CFG),
+    ConditionalPass::always(propagate_stability::PROPAGATE_STABILITY),
+    ConditionalPass::always(lint::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),
+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 {

src/librustdoc/passes/propagate_doc_cfg.rs

@@ -11,11 +11,8 @@ 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) 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 {
     CfgPropagator { parent_cfg: None, parent: None, cx }.fold_crate(cr)

src/librustdoc/passes/propagate_stability.rs

@@ -14,11 +14,8 @@ 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) 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,11 +6,8 @@ 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",
-};
+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 {
     let mut stripper = AliasedNonLocalStripper { tcx: cx.tcx };

src/librustdoc/passes/strip_hidden.rs

@@ -13,11 +13,7 @@ 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",
-};
+pub(crate) const STRIP_HIDDEN: Pass = Pass { name: "strip-hidden", run: Some(strip_hidden) };
 
 /// Strip items marked `#[doc(hidden)]`
 pub(crate) fn strip_hidden(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate {

src/librustdoc/passes/strip_priv_imports.rs

@@ -6,11 +6,8 @@ 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",
-};
+pub(crate) const STRIP_PRIV_IMPORTS: Pass =
+    Pass { name: "strip-priv-imports", run: Some(strip_priv_imports) };
 
 pub(crate) fn strip_priv_imports(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate {
     let is_json_output = cx.is_json_output();

src/librustdoc/passes/strip_private.rs

@@ -6,12 +6,7 @@ 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",
-};
+pub(crate) const STRIP_PRIVATE: Pass = Pass { name: "strip-private", run: Some(strip_private) };
 
 /// Strip private items from the point of view of a crate or externally from a
 /// crate, specified by the `xcrate` flag.