Struct rustdoc::core::DocContext

pub(crate) struct DocContext<'tcx> {
    pub(crate) tcx: TyCtxt<'tcx>,
    pub(crate) resolver: Rc<RefCell<BoxedResolver>>,
    pub(crate) param_env: ParamEnv<'tcx>,
    pub(crate) external_traits: Rc<RefCell<FxHashMap<DefId, TraitWithExtraInfo>>>,
    pub(crate) active_extern_traits: FxHashSet<DefId>,
    pub(crate) ty_substs: FxHashMap<DefId, Type>,
    pub(crate) lt_substs: FxHashMap<DefId, Lifetime>,
    pub(crate) ct_substs: FxHashMap<DefId, Constant>,
    pub(crate) impl_trait_bounds: FxHashMap<ImplTraitParam, Vec<GenericBound>>,
    pub(crate) fake_def_ids: FxHashMap<CrateNum, DefIndex>,
    pub(crate) generated_synthetics: FxHashSet<(Ty<'tcx>, DefId)>,
    pub(crate) auto_traits: Vec<DefId>,
    pub(crate) render_options: RenderOptions,
    pub(crate) module_trait_cache: FxHashMap<DefId, FxHashSet<DefId>>,
    pub(crate) cache: Cache,
    pub(crate) inlined: FxHashSet<DefId>,
    pub(crate) output_format: OutputFormat,
}

Fields

tcx: TyCtxt<'tcx>

resolver: Rc<RefCell<BoxedResolver>>

Name resolver. Used for intra-doc links.

The Rc<RefCell<...>> wrapping is needed because that is what’s returned by Queries::expansion().

param_env: ParamEnv<'tcx>

Used for normalization.

Most of this logic is copied from rustc_lint::late.

external_traits: Rc<RefCell<FxHashMap<DefId, TraitWithExtraInfo>>>

Later on moved through clean::Crate into cache

active_extern_traits: FxHashSet<DefId>

Used while populating external_traits to ensure we don’t process the same trait twice at the same time.

ty_substs: FxHashMap<DefId, Type>

Table DefId of type parameter -> substituted type

lt_substs: FxHashMap<DefId, Lifetime>

Table DefId of lifetime parameter -> substituted lifetime

ct_substs: FxHashMap<DefId, Constant>

Table DefId of const parameter -> substituted const

impl_trait_bounds: FxHashMap<ImplTraitParam, Vec<GenericBound>>

Table synthetic type parameter for impl Trait in argument position -> bounds

fake_def_ids: FxHashMap<CrateNum, DefIndex>

generated_synthetics: FxHashSet<(Ty<'tcx>, DefId)>

Auto-trait or blanket impls processed so far, as (self_ty, trait_def_id).

auto_traits: Vec<DefId>

render_options: RenderOptions

The options given to rustdoc that could be relevant to a pass.

module_trait_cache: FxHashMap<DefId, FxHashSet<DefId>>

The traits in scope for a given module.

See collect_intra_doc_links::traits_implemented_by for more details. map<module, set<trait>>

cache: Cache

This same cache is used throughout rustdoc, including in crate::html::render.

inlined: FxHashSet<DefId>

Used by clean::inline to tell if an item has already been inlined.

output_format: OutputFormat

Used by calculate_doc_coverage.

Implementations

impl<'tcx> DocContext<'tcx>

pub(crate) fn sess(&self) -> &'tcx Session

pub(crate) fn with_param_env<T, F: FnOnce(&mut Self) -> T>(
    &mut self,
    def_id: DefId,
    f: F
) -> T

pub(crate) fn enter_resolver<F, R>(&self, f: F) -> R where
    F: FnOnce(&mut Resolver<'_>) -> R, 

pub(crate) fn enter_alias<F, R>(
    &mut self,
    ty_substs: FxHashMap<DefId, Type>,
    lt_substs: FxHashMap<DefId, Lifetime>,
    ct_substs: FxHashMap<DefId, Constant>,
    f: F
) -> R where
    F: FnOnce(&mut Self) -> R, 

Call the closure with the given parameters set as the substitutions for a type alias’ RHS.

pub(crate) fn next_def_id(&mut self, crate_num: CrateNum) -> DefId

Create a new “fake” DefId.

This is an ugly hack, but it’s the simplest way to handle synthetic impls without greatly refactoring either rustdoc or rustc_middle. In particular, allowing new DefIds to be registered after the AST is constructed would require storing the DefId mapping in a RefCell, decreasing the performance for normal compilation for very little gain.

Instead, we construct “fake” DefIds, which start immediately after the last DefId. In the Debug impl for clean::Item, we explicitly check for fake DefIds, as we’ll end up with a panic if we use the DefId Debug impl for fake DefIds.

pub(crate) fn as_local_hir_id(tcx: TyCtxt<'_>, def_id: DefId) -> Option<HirId>

Like hir().local_def_id_to_hir_id(), but skips calling it on fake DefIds. (This avoids a slice-index-out-of-bounds panic.)