Struct rustdoc::core::DocContext

pub(crate) struct DocContext<'tcx> {
    pub(crate) tcx: TyCtxt<'tcx>,
    pub(crate) resolver: Rc<RefCell<BoxedResolver>>,
    pub(crate) renderinfo: RefCell<RenderInfo>,
    pub(crate) external_traits: Rc<RefCell<FxHashMap<DefId, Trait>>>,
    pub(crate) active_extern_traits: RefCell<FxHashSet<DefId>>,
    pub(crate) ty_substs: RefCell<FxHashMap<DefId, Type>>,
    pub(crate) lt_substs: RefCell<FxHashMap<DefId, Lifetime>>,
    pub(crate) ct_substs: RefCell<FxHashMap<DefId, Constant>>,
    pub(crate) impl_trait_bounds: RefCell<FxHashMap<ImplTraitParam, Vec<GenericBound>>>,
    pub(crate) fake_def_ids: RefCell<FxHashMap<CrateNum, DefId>>,
    pub(crate) all_fake_def_ids: RefCell<FxHashSet<DefId>>,
    pub(crate) generated_synthetics: RefCell<FxHashSet<(Ty<'tcx>, DefId)>>,
    pub(crate) auto_traits: Vec<DefId>,
    pub(crate) render_options: RenderOptions,
    pub(crate) module_trait_cache: RefCell<FxHashMap<DefId, FxHashSet<DefId>>>,
}

Fields

tcx: TyCtxt<'tcx>

resolver: Rc<RefCell<BoxedResolver>>

renderinfo: RefCell<RenderInfo>

Later on moved into CACHE_KEY

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

Later on moved through clean::Crate into CACHE_KEY

active_extern_traits: RefCell<FxHashSet<DefId>>

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

ty_substs: RefCell<FxHashMap<DefId, Type>>

Table DefId of type parameter -> substituted type

lt_substs: RefCell<FxHashMap<DefId, Lifetime>>

Table DefId of lifetime parameter -> substituted lifetime

ct_substs: RefCell<FxHashMap<DefId, Constant>>

Table DefId of const parameter -> substituted const

impl_trait_bounds: RefCell<FxHashMap<ImplTraitParam, Vec<GenericBound>>>

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

fake_def_ids: RefCell<FxHashMap<CrateNum, DefId>>

all_fake_def_ids: RefCell<FxHashSet<DefId>>

generated_synthetics: RefCell<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: RefCell<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>>

Implementations

impl<'tcx> DocContext<'tcx>

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

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

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

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

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

pub(crate) fn as_local_hir_id(&self, 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.)

pub(crate) fn stability(&self, id: HirId) -> Option<Stability>

pub(crate) fn deprecation(&self, id: HirId) -> Option<Deprecation>