diff --git a/src/librustdoc/calculate_doc_coverage.rs b/src/librustdoc/calculate_doc_coverage.rs index ae05e362f2383..3c180d9afd25d 100644 --- a/src/librustdoc/calculate_doc_coverage.rs +++ b/src/librustdoc/calculate_doc_coverage.rs @@ -1,4 +1,7 @@ -//! Calculates information used for the --show-coverage flag. +//! Calculates information used for the `--show-coverage` flag. +//! +//! More specifically, it counts the number of items with documentation, ones with +//! "examples" (i.e., non-ignored Rust code blocks) and various totals. use std::collections::BTreeMap; use std::fs::{File, create_dir_all}; @@ -17,7 +20,7 @@ use crate::core::DocContext; use crate::docfs::PathError; use crate::error::Error; use crate::html::markdown::{ErrorCodes, find_testable_code}; -use crate::passes::{Tests, should_have_doc_example}; +use crate::passes::check_doc_test_visibility::{Tests, should_have_doc_example}; use crate::visit::DocVisitor; use crate::{clean, try_err}; diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index 3ad07dd35ccf0..941632f0d283a 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -26,7 +26,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}; @@ -428,40 +427,7 @@ 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 should_test = matches.opt_present("test"); - let show_coverage = matches.opt_present("show-coverage"); let output_format_s = matches.opt_str("output-format"); let output_format = match output_format_s.as_deref() { diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index c30c68a1fa5c8..ad6718e75466e 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -26,7 +26,7 @@ pub(crate) use rustc_session::config::{Options, UnstableOptions}; use rustc_span::source_map; use rustc_span::symbol::sym; use rustc_structures::CrateType; -use tracing::{debug, info}; +use tracing::debug; use crate::clean::inline::build_trait; use crate::clean::{self, ItemId}; @@ -34,8 +34,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> { pub(crate) tcx: TyCtxt<'tcx>, @@ -428,31 +426,8 @@ 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; - } - } - } + let store; + (krate, store) = passes::run(krate, &mut ctxt, show_coverage); if show_coverage && let Err(error) = crate::calculate_doc_coverage::run(&krate, &mut ctxt, &render_options) @@ -466,9 +441,7 @@ pub(crate) fn run_global_ctxt( 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 }; - collector.resolve_ambiguities(); + passes::finalize(&mut ctxt, store); tcx.dcx().abort_if_errors(); diff --git a/src/librustdoc/passes/check_doc_test_visibility.rs b/src/librustdoc/passes/check_doc_test_visibility.rs index 13452539c8295..17f69b68b537d 100644 --- a/src/librustdoc/passes/check_doc_test_visibility.rs +++ b/src/librustdoc/passes/check_doc_test_visibility.rs @@ -10,27 +10,19 @@ use rustc_macros::Diagnostic; use rustc_middle::lint::LintLevelSource; 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::{ CodeLineMapping, 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>, } -pub(crate) fn check_doc_test_visibility(krate: Crate, cx: &mut DocContext<'_>) -> Crate { +pub(super) fn check_doc_test_visibility(krate: Crate, cx: &mut DocContext<'_>) -> Crate { let mut coll = DocTestVisibilityLinter { cx }; coll.visit_crate(&krate); krate diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs index 38d285f4fe86d..7aee8dba82e1a 100644 --- a/src/librustdoc/passes/collect_intra_doc_links.rs +++ b/src/librustdoc/passes/collect_intra_doc_links.rs @@ -1,6 +1,6 @@ -//! This module implements [RFC 1946]: Intra-rustdoc-links +//! Resolves intra-doc links ([RFC 1946]). //! -//! [RFC 1946]: https://github.com/rust-lang/rfcs/blob/master/text/1946-intra-rustdoc-links.md +//! [RFC 1946]: https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html use std::borrow::Cow; use std::fmt::Display; @@ -36,23 +36,19 @@ use crate::clean::{self, Crate, Item, ItemId, ItemLink, PrimitiveType, reexport_ 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>( +pub(super) fn collect_intra_doc_links( krate: Crate, - cx: &'a mut DocContext<'tcx>, -) -> (Crate, LinkCollector<'a, 'tcx>) { - let mut collector = LinkCollector { - cx, - visited_links: FxHashMap::default(), - ambiguous_links: FxIndexMap::default(), - }; + cx: &mut DocContext<'_>, +) -> (Crate, LinkCollection) { + let mut collector = LinkCollector { cx, links: LinkCollection::default() }; collector.visit_crate(&krate); - (krate, collector) + (krate, collector.links) +} + +pub(super) fn resolve_ambiguous_links(links: LinkCollection, cx: &mut DocContext<'_>) { + LinkCollector { cx, links }.resolve_ambiguities(); } fn filter_assoc_items_by_name_and_namespace( @@ -252,11 +248,16 @@ impl OwnedDiagnosticInfo { } } -pub(crate) struct LinkCollector<'a, 'tcx> { - pub(crate) cx: &'a mut DocContext<'tcx>, +struct LinkCollector<'a, 'tcx> { + cx: &'a mut DocContext<'tcx>, + links: LinkCollection, +} + +#[derive(Default)] +pub(super) struct LinkCollection { /// Cache the resolved links so we can avoid resolving (and emitting errors for) the same link. /// The link will be `None` if it could not be resolved (i.e. the error was cached). - pub(crate) visited_links: FxHashMap)>>, + visited: FxHashMap)>>, /// According to `rustc_resolve`, these links are ambiguous. /// /// However, we cannot link to an item that has been stripped from the documentation. If all @@ -267,7 +268,7 @@ pub(crate) struct LinkCollector<'a, 'tcx> { /// We could get correct results by simply delaying everything. This would have fewer happy /// codepaths, but we want to distinguish different kinds of error conditions, and this is easy /// to do by resolving links as soon as possible. - pub(crate) ambiguous_links: FxIndexMap<(ItemId, String), Vec>, + ambiguous: FxIndexMap<(ItemId, String), Vec>, } pub(crate) struct AmbiguousLinks { @@ -1216,7 +1217,8 @@ impl LinkCollector<'_, '_> { resolved, }; - self.ambiguous_links + self.links + .ambiguous .entry((item.item_id, path_str.to_string())) .or_default() .push(links); @@ -1272,8 +1274,8 @@ impl LinkCollector<'_, '_> { || !did.is_local() } - pub(crate) fn resolve_ambiguities(&mut self) { - let mut ambiguous_links = mem::take(&mut self.ambiguous_links); + fn resolve_ambiguities(&mut self) { + let mut ambiguous_links = mem::take(&mut self.links.ambiguous); for ((item_id, path_str), info_items) in ambiguous_links.iter_mut() { for info in info_items { info.resolved.retain(|(res, _)| match res { @@ -1523,7 +1525,7 @@ impl LinkCollector<'_, '_> { // which we want in some cases but not in others. cache_errors: bool, ) -> Option)>> { - if let Some(res) = self.visited_links.get(&key) + if let Some(res) = self.links.visited.get(&key) && (res.is_some() || cache_errors) { return res.clone().map(|r| vec![r]); @@ -1570,9 +1572,9 @@ impl LinkCollector<'_, '_> { out.push((res, fragment)); } if let [r] = out.as_slice() { - self.visited_links.insert(key, Some(r.clone())); + self.links.visited.insert(key, Some(r.clone())); } else if cache_errors { - self.visited_links.insert(key, None); + self.links.visited.insert(key, None); } Some(out) } diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs index 1651690653786..1bfac8e67748c 100644 --- a/src/librustdoc/passes/collect_trait_impls.rs +++ b/src/librustdoc/passes/collect_trait_impls.rs @@ -1,6 +1,7 @@ -//! Collects trait impls for each item in the crate. For example, if a crate -//! defines a struct that implements a trait, this pass will note that the -//! struct implements that trait. +//! Collects trait impls for each item in the crate. +//! +//! For example, if a crate defines a struct that implements a trait, +//! this pass will note that the struct implements that trait. use rustc_data_structures::fx::FxHashSet; use rustc_errors::FatalError; @@ -11,19 +12,12 @@ use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::kw; 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 { +pub(super) 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 // we try to get auto and blanket implementations. diff --git a/src/librustdoc/passes/lint.rs b/src/librustdoc/passes/lint.rs index bb952b32393cf..bcee358b48d62 100644 --- a/src/librustdoc/passes/lint.rs +++ b/src/librustdoc/passes/lint.rs @@ -1,5 +1,4 @@ -//! Runs several rustdoc lints, consolidating them into a single pass for -//! efficiency and simplicity. +//! Runs several rustdoc lints, consolidating them into a single pass for efficiency and simplicity. mod bare_urls; mod check_code_block_syntax; @@ -8,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(super) 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 725c2be4e2121..0793ce88a1066 100644 --- a/src/librustdoc/passes/mod.rs +++ b/src/librustdoc/passes/mod.rs @@ -1,119 +1,63 @@ -//! Contains information about "passes", used to modify crate information during the documentation -//! process. +//! The definitions of *passes* which transform crate information. -use self::Condition::*; -use crate::clean; +use crate::clean::Crate; 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 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, Tests, should_have_doc_example, -}; - mod collect_trait_impls; -pub(crate) use self::collect_trait_impls::COLLECT_TRAIT_IMPLS; - 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) -> clean::Crate>, - pub(crate) description: &'static str, -} +mod propagate_doc_cfg; +mod propagate_stability; +mod strip_aliased_non_local; +mod strip_hidden; +mod strip_priv_imports; +mod strip_private; -/// 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, +#[derive(Default)] +pub(crate) struct Store { + links: collect_intra_doc_links::LinkCollection, } -/// 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, -} +#[tracing::instrument(level = "info", skip_all)] +pub(crate) fn run( + mut krate: Crate, + cx: &mut DocContext<'_>, + show_coverage: bool, +) -> (Crate, Store) { + macro_rules! run { + ($name:ident($( $args:tt )*)) => {{ + tracing::debug!("running pass `{}`", stringify!($name)); + cx.tcx.sess.time(stringify!($name), || $name::$name($( $args )*)) + }}; + } -/// The full list of passes. -pub(crate) const PASSES: &[Pass] = &[ - CHECK_DOC_TEST_VISIBILITY, - PROPAGATE_DOC_CFG, - STRIP_ALIASED_NON_LOCAL, - STRIP_HIDDEN, - STRIP_PRIVATE, - STRIP_PRIV_IMPORTS, - PROPAGATE_STABILITY, - COLLECT_INTRA_DOC_LINKS, - COLLECT_TRAIT_IMPLS, - RUN_LINTS, -]; + let mut store = Store::default(); -/// 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(STRIP_ALIASED_NON_LOCAL), - ConditionalPass::always(PROPAGATE_DOC_CFG), - 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_STABILITY), - ConditionalPass::always(RUN_LINTS), -]; + if !show_coverage { + krate = run!(collect_trait_impls(krate, cx)); + krate = run!(check_doc_test_visibility(krate, cx)); + krate = run!(strip_aliased_non_local(krate, cx)); + krate = run!(propagate_doc_cfg(krate, cx)); + } -/// 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), -]; + krate = run!(strip_hidden(krate, cx)); + krate = run!(strip_private(krate, cx)); -impl ConditionalPass { - pub(crate) const fn always(pass: Pass) -> Self { - Self::new(pass, Always) + if !show_coverage { + krate = run!(strip_priv_imports(krate, cx)); + (krate, store.links) = run!(collect_intra_doc_links(krate, cx)); + krate = run!(propagate_stability(krate, cx)); + krate = run!(lint(krate, cx)); } - pub(crate) const fn new(pass: Pass, condition: Condition) -> Self { - ConditionalPass { pass, condition } - } + (krate, store) } -/// Returns the given default set of passes. -pub(crate) fn defaults(show_coverage: bool) -> &'static [ConditionalPass] { - if show_coverage { COVERAGE_PASSES } else { DEFAULT_PASSES } +/// To be run after the cache in [`DocContext`] has been fully populated. +pub(crate) fn finalize(cx: &mut DocContext<'_>, store: Store) { + collect_intra_doc_links::resolve_ambiguous_links(store.links, cx); } diff --git a/src/librustdoc/passes/propagate_doc_cfg.rs b/src/librustdoc/passes/propagate_doc_cfg.rs index e15bb657b7867..0d16141fa09a1 100644 --- a/src/librustdoc/passes/propagate_doc_cfg.rs +++ b/src/librustdoc/passes/propagate_doc_cfg.rs @@ -1,4 +1,6 @@ -//! Propagates [`#[doc(cfg(...))]`](https://github.com/rust-lang/rust/issues/43781) to child items. +//! Propagates `#[doc(cfg(…))]` ([RFC 3631]) to child items. +//! +//! [RFC 3631]: https://rust-lang.github.io/rfcs/3631-rustdoc-cfgs-handling.html use rustc_data_structures::fx::FxHashMap; use rustc_hir::attrs::{AttributeKind, DocAttribute}; @@ -9,15 +11,8 @@ use crate::clean::inline::{load_attrs, merge_attrs}; use crate::clean::{CfgInfo, Crate, Item, ItemId, 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 { +pub(super) fn propagate_doc_cfg(cr: Crate, cx: &mut DocContext<'_>) -> Crate { if cx.tcx.features().doc_cfg() { CfgPropagator { cx, cfg_info: CfgInfo::default(), impl_cfg_info: FxHashMap::default() } .fold_crate(cr) diff --git a/src/librustdoc/passes/propagate_stability.rs b/src/librustdoc/passes/propagate_stability.rs index 6700ca649d7be..9afde1e6195e7 100644 --- a/src/librustdoc/passes/propagate_stability.rs +++ b/src/librustdoc/passes/propagate_stability.rs @@ -12,15 +12,8 @@ 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 { +pub(super) fn propagate_stability(cr: Crate, cx: &mut DocContext<'_>) -> Crate { let crate_stability = cx.tcx.lookup_stability(CRATE_DEF_ID); StabilityPropagator { parent_stability: crate_stability, cx }.fold_crate(cr) } diff --git a/src/librustdoc/passes/strip_aliased_non_local.rs b/src/librustdoc/passes/strip_aliased_non_local.rs index 18865f90e9031..06418bf97ed2b 100644 --- a/src/librustdoc/passes/strip_aliased_non_local.rs +++ b/src/librustdoc/passes/strip_aliased_non_local.rs @@ -1,18 +1,16 @@ +//! Strips all non-local private aliases items from the output. + use rustc_middle::ty::{TyCtxt, Visibility}; 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(super) 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 e4c8a7b82a16d..95219d5e10a63 100644 --- a/src/librustdoc/passes/strip_hidden.rs +++ b/src/librustdoc/passes/strip_hidden.rs @@ -1,4 +1,4 @@ -//! Strip all doc(hidden) items from the output. +//! Strip all `#[doc(hidden)]` items from the output. use std::mem; @@ -10,16 +10,13 @@ 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}; +use crate::passes::ImplStripper; -pub(crate) const STRIP_HIDDEN: Pass = Pass { - name: "strip-hidden", - run: Some(strip_hidden), - description: "strips all `#[doc(hidden)]` items from the output", -}; +pub(super) fn strip_hidden(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate { + if cx.document_hidden() { + return krate; + } -/// Strip items marked `#[doc(hidden)]` -pub(crate) fn strip_hidden(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate { 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 a169797e00b2a..9a432c3bad343 100644 --- a/src/librustdoc/passes/strip_priv_imports.rs +++ b/src/librustdoc/passes/strip_priv_imports.rs @@ -1,18 +1,16 @@ -//! Strips all private import statements (use, extern crate) from a -//! crate. +//! Strips all private imports (`use`, `extern crate`) from a crate. use crate::clean; use crate::core::DocContext; use crate::fold::DocFolder; -use crate::passes::{ImportStripper, Pass}; +use crate::passes::ImportStripper; -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(super) fn strip_priv_imports(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate { + if !cx.document_private() { + // We don't need to do anything since it'll be handled by the `strip_private` pass. + return krate; + } -pub(crate) fn strip_priv_imports(krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate { let is_json_output = cx.is_json_output(); ImportStripper { tcx: cx.tcx, is_json_output, document_hidden: cx.document_hidden() } .fold_crate(krate) diff --git a/src/librustdoc/passes/strip_private.rs b/src/librustdoc/passes/strip_private.rs index 045bf0c0be029..54c8e9daedd17 100644 --- a/src/librustdoc/passes/strip_private.rs +++ b/src/librustdoc/passes/strip_private.rs @@ -1,21 +1,17 @@ -//! Strip all private items from the output. Additionally implies strip_priv_imports. -//! Basically, the goal is to remove items that are not relevant for public documentation. +//! Strip all private items from the output. +//! +//! Implies `strip_priv_imports`. use crate::clean::{self, ItemIdSet}; use crate::core::DocContext; use crate::fold::DocFolder; -use crate::passes::{ImplStripper, ImportStripper, Pass, Stripper}; +use crate::passes::{ImplStripper, ImportStripper, 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(super) fn strip_private(mut krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate { + if cx.document_private() { + return krate; + } -/// 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 { // 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 0243f6cd533a0..0000000000000 --- a/tests/rustdoc-ui/issues/issue-91713.stdout +++ /dev/null @@ -1,27 +0,0 @@ -Available passes for running rustdoc: -check_doc_test_visibility - run various visibility-related lints on doctests - propagate-doc-cfg - propagates `#[doc(cfg(...))]` to child items -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-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 - run-lints - runs some of rustdoc's lints - -Default passes for rustdoc: - collect-trait-impls -check_doc_test_visibility -strip-aliased-non-local - propagate-doc-cfg - 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-stability - run-lints - -Passes run with `--show-coverage`: - strip-hidden (when not --document-hidden-items) - strip-private (when not --document-private-items)