Struct rustc_typeck::collect::ItemCtxt

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

Context specific to some particular item. This is what implements AstConv. It 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>

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

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

pub fn hir_id(&self) -> HirId

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

impl<'tcx> ItemCtxt<'tcx>

pub(in collect) fn type_parameter_bounds_in_generics(
    &self,
    ast_generics: &'tcx Generics<'tcx>,
    param_id: HirId,
    ty: Ty<'tcx>,
    only_self_bounds: OnlySelfBounds
) -> 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.

Trait Implementations

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

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

pub fn item_def_id(&self) -> Option<DefId>

pub fn default_constness_for_trait_bounds(&self) -> Constness

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

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

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

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

pub fn allow_ty_infer(&self) -> bool

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

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

Returns the type to use when a type is omitted.

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

Returns the const to use when a const is omitted.

pub 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.

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

Normalize an associated type coming from the user.

pub fn set_tainted_by_errors(&self)

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.

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