Struct rustc_hir_analysis::collect::ItemCtxt

pub struct ItemCtxt<'tcx> {
    tcx: TyCtxt<'tcx>,
    item_def_id: LocalDefId,
    tainted_by_errors: Cell<Option<ErrorGuaranteed>>,
}

Context specific to some particular item. This is what implements HirTyLowerer.

ItemCtxt vs FnCtxt

ItemCtxt is primarily used to type-check item signatures and lower them from HIR to their ty::Ty representation, which is exposed using HirTyLowerer. It’s also used for the bodies of items like structs where the body (the fields) are just signatures.

This is in contrast to FnCtxt, which is used to type-check bodies of functions, closures, and consts – anywhere that expressions and statements show up.

An important thing to note is that ItemCtxt does no inference – it has no InferCtxt – while FnCtxt does do inference.

Trait predicates

ItemCtxt has information about the predicates that are defined on the trait. Unfortunately, this predicate information is available in various different forms at various points in the process. So we can’t just store a pointer to e.g., the HIR or the parsed ty form, we have to be more flexible. To this end, the ItemCtxt is parameterized by a DefId that it uses to satisfy probe_ty_param_bounds requests, drawing the information from the HIR (hir::Generics), recursively.

Fields

tcx: TyCtxt<'tcx>

item_def_id: LocalDefId

tainted_by_errors: Cell<Option<ErrorGuaranteed>>

Implementations

impl<'tcx> ItemCtxt<'tcx>

fn probe_ty_param_bounds_in_generics( &self, hir_generics: &'tcx Generics<'tcx>, param_def_id: LocalDefId, ty: Ty<'tcx>, filter: PredicateFilter ) -> Vec<(Clause<'tcx>, Span)>

Finds bounds from hir::Generics.

This requires scanning through the HIR. We do this to avoid having to lower all the bounds, which would create artificial cycles. Instead, we can only lower the bounds for a type parameter X if X::Foo is used.

fn bound_defines_assoc_item( &self, b: &GenericBound<'_>, assoc_name: Ident ) -> bool

impl<'tcx> ItemCtxt<'tcx>

pub fn new(tcx: TyCtxt<'tcx>, item_def_id: LocalDefId) -> ItemCtxt<'tcx>

pub fn lower_ty(&self, hir_ty: &Ty<'tcx>) -> Ty<'tcx>

pub fn hir_id(&self) -> HirId

pub fn node(&self) -> Node<'tcx>

fn check_tainted_by_errors(&self) -> Result<(), ErrorGuaranteed>

Trait Implementations

impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx>

fn tcx(&self) -> TyCtxt<'tcx>

fn item_def_id(&self) -> DefId

Returns the DefId of the overarching item whose constituents get lowered.

fn allow_infer(&self) -> bool

Returns true if the current context allows the use of inference variables.

fn re_infer(&self, _: Option<&GenericParamDef>, _: Span) -> Option<Region<'tcx>>

Returns the region to use when a lifetime is omitted (and not elided).

fn ty_infer(&self, _: Option<&GenericParamDef>, span: Span) -> Ty<'tcx>

Returns the type to use when a type is omitted.

fn ct_infer( &self, ty: Ty<'tcx>, _: Option<&GenericParamDef>, span: Span ) -> Const<'tcx>

Returns the const to use when a const is omitted.

fn probe_ty_param_bounds( &self, span: Span, def_id: LocalDefId, assoc_name: Ident ) -> GenericPredicates<'tcx>

Probe bounds in scope where the bounded type coincides with the given type parameter.

fn lower_assoc_ty( &self, span: Span, item_def_id: DefId, item_segment: &PathSegment<'tcx>, poly_trait_ref: PolyTraitRef<'tcx> ) -> Ty<'tcx>

Lower an associated type to a projection.

fn probe_adt(&self, _span: Span, ty: Ty<'tcx>) -> Option<AdtDef<'tcx>>

Returns AdtDef if ty is an ADT.

fn record_ty(&self, _hir_id: HirId, _ty: Ty<'tcx>, _span: Span)

Record the lowered type of a HIR node in this context.

fn infcx(&self) -> Option<&InferCtxt<'tcx>>

The inference context of the lowering context if applicable.

fn set_tainted_by_errors(&self, err: ErrorGuaranteed)

Taint the context with errors.

fn lowerer(&self) -> &dyn HirTyLowerer<'tcx>

where Self: Sized,

Convenience method for coercing the lowering context into a trait object type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes