Change:
Using to document private types of the current workspace exposes external types private implementation details (in this case private fields). I would expect the expansion to limit itself to public fields. e.g. gives ! <details<summary<coderustc --version --verbose</code</summary<p</p</detailsr?
I suppose it's "ok" since you used the option. I'll add it to the next rustdoc team meeting agenda to be confirmed by the team.
Rendered output for anyone wondering: !
I'll summarize the exchange I had with Guillaume on matrix. First, the flag I'm talking about is the one you provide to . does not blindly pass the flag to but only for crates you own in your current workspace. That means that when documenting your workspace with . Private items, fields of your crates are shown contrary to your dependencies. Regarding design, it seems weird to me that aliased type expansion shows private implementation details of dependencies (e.g. for the given example). I would personally expect something like:

Discussion:
mod stripper; pub(crate) use stripper::*; <ins> mod strip_aliased_non_local; pub(crate) use self::strip_aliased_non_local::STRIP_ALIASED_NON_LOCAL; </ins> mod strip_hidden; pub(crate) use self::strip_hidden::STRIP_HIDDEN;

pub(crate) const PASSES: &[Pass] = &[ CHECK_CUSTOM_CODE_CLASSES, CHECK_DOC_TEST_VISIBILITY, <ins> STRIP_ALIASED_NON_LOCAL, </ins> STRIP_HIDDEN, STRIP_PRIVATE, STRIP_PRIV_IMPORTS,

ConditionalPass::always(CHECK_CUSTOM_CODE_CLASSES), ConditionalPass::always(COLLECT_TRAIT_IMPLS), ConditionalPass::always(CHECK_DOC_TEST_VISIBILITY), <ins> ConditionalPass::always(STRIP_ALIASED_NON_LOCAL), </ins> ConditionalPass::new(STRIP_HIDDEN, WhenNotDocumentHidden), ConditionalPass::new(STRIP_PRIVATE, WhenNotDocumentPrivate), ConditionalPass::new(STRIP_PRIV_IMPORTS, WhenDocumentPrivate),

<ins> use rustc_middle::ty::TyCtxt; use rustc_middle::ty::Visibility; use crate::clean; use crate::clean::Item; use crate::core::DocContext; use crate::fold::{strip_item, DocFolder}; use crate::passes::Pass; pub(crate) const STRIP_ALIASED_NON_LOCAL: Pass = Pass { name: "strip-aliased-non-local", run: 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 { let mut stripper = AliasedNonLocalStripper { tcx: cx.tcx }; stripper.fold_crate(krate) } struct AliasedNonLocalStripper<'tcx> { tcx: TyCtxt<'tcx>, } impl<'tcx> DocFolder for AliasedNonLocalStripper<'tcx> { fn fold_item(&mut self, i: Item) -> Option<Item> { Some(match *i.kind { clean::TypeAliasItem(..) => { let mut stripper = NonLocalStripper { tcx: self.tcx }; // don't call `fold_item` as that could strip the type-alias it-self // which we don't want to strip out stripper.fold_item_recur(i) } _ => self.fold_item_recur(i), }) } } struct NonLocalStripper<'tcx> { tcx: TyCtxt<'tcx>, } impl<'tcx> DocFolder for NonLocalStripper<'tcx> { fn fold_item(&mut self, i: Item) -> Option<Item> { // If not local, we want to respect the original visibility of // the field and not the one given by the user for the currrent crate. // // FIXME(#125009): Not-local should probably consider same Cargo workspace if !i.def_id().map_or(true, |did| did.is_local()) { if i.visibility(self.tcx) != Some(Visibility::Public) || i.is_doc_hidden() { return Some(strip_item(i)); } } Some(self.fold_item_recur(i)) } } </ins>

Available passes for running rustdoc: check-custom-code-classes - check for custom code classes without the feature-gate enabled check_doc_test_visibility - run various visibility-related lints on doctests <ins> strip-aliased-non-local - strips all non-local private aliased items from the output </ins> 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

check-custom-code-classes collect-trait-impls check_doc_test_visibility <ins> strip-aliased-non-local </ins> strip-hidden  (when not --document-hidden-items) strip-private  (when not --document-private-items) strip-priv-imports  (when --document-private-items)

<ins> //! This test makes sure that with never show the inner fields in the //! aliased type view of type alias. //@ compile-flags: -Z unstable-options --document-private-items #![crate_name = "foo"] use std::collections::BTreeMap; // @has 'foo/type.FooBar.html' '//*[@class="rust item-decl"]/code' 'struct FooBar { /* private fields */ }' pub type FooBar = BTreeMap<u32, String>; </ins>

<ins> //! This test makes sure that with never show the inner fields in the //! aliased type view of type alias. #![crate_name = "foo"] use std::collections::BTreeMap; // @has 'foo/type.FooBar.html' '//*[@class="rust item-decl"]/code' 'struct FooBar { /* private fields */ }' pub type FooBar = BTreeMap<u32, String>; </ins>