Struct rustc_hir_analysis::collect::ItemCtxt

pub struct ItemCtxt<'tcx> {
    tcx: TyCtxt<'tcx>,
    item_def_id: DefId,
}

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

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 AstConv. 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 AST 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 get_type_parameter_bounds requests, drawing the information from the AST (hir::Generics), recursively.

Fields

tcx: TyCtxt<'tcx>

item_def_id: DefId

Implementations

impl<'tcx> ItemCtxt<'tcx>

fn type_parameter_bounds_in_generics(
    &self,
    ast_generics: &'tcx Generics<'tcx>,
    param_def_id: LocalDefId,
    ty: Ty<'tcx>,
    only_self_bounds: OnlySelfBounds,
    assoc_name: Option<Ident>
) -> Vec<(Predicate<'tcx>, Span)>

Finds bounds from hir::Generics. This requires scanning through the AST. We do this to avoid having to convert all the bounds, which would create artificial cycles. Instead, we can only convert 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: DefId) -> ItemCtxt<'tcx>

pub fn to_ty(&self, ast_ty: &Ty<'_>) -> Ty<'tcx>

pub fn hir_id(&self) -> HirId

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

Trait Implementations

impl<'tcx> AstConv<'tcx> for ItemCtxt<'tcx>

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

fn item_def_id(&self) -> DefId

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

Returns predicates in scope of the form X: Foo<T>, where X is a type parameter X with the given id def_id and T matches assoc_name. This is a subset of the full set of predicates.

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

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

fn allow_ty_infer(&self) -> bool

Returns true if _ is allowed in type signatures in the current context.

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 projected_ty_from_poly_trait_ref(
    &self,
    span: Span,
    item_def_id: DefId,
    item_segment: &PathSegment<'_>,
    poly_trait_ref: PolyTraitRef<'tcx>
) -> Ty<'tcx>

Projecting an associated type from a (potentially) higher-ranked trait reference is more complicated, because of the possibility of late-bound regions appearing in the associated type binding. This is not legal in function signatures for that reason. In a function body, we can always handle it because we can use inference variables to remove the late-bound regions.

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

Normalize an associated type coming from the user.

fn set_tainted_by_errors(&self, _: ErrorGuaranteed)

Invoked when we encounter an error from some prior pass (e.g., resolve) that is translated into a ty-error. This is used to help suppress derived errors typeck might otherwise report.

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

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