Struct rustc_typeck::check::generator_interior::drop_ranges::cfg_build::DropRangeVisitor

struct DropRangeVisitor<'a, 'tcx> {
    hir: Map<'tcx>,
    places: ConsumedAndBorrowedPlaces,
    drop_ranges: DropRangesBuilder,
    expr_index: PostOrderId,
    tcx: TyCtxt<'tcx>,
    typeck_results: &'a TypeckResults<'tcx>,
}

This struct is used to gather the information for DropRanges to determine the regions of the HIR tree for which a value is dropped.

We are interested in points where a variables is dropped or initialized, and the control flow of the code. We identify locations in code by their post-order traversal index, so it is important for this traversal to match that in RegionResolutionVisitor and InteriorVisitor.

We make several simplifying assumptions, with the goal of being more conservative than necessary rather than less conservative (since being less conservative is unsound, but more conservative is still safe). These assumptions are:

1. Moving a variable a counts as a move of the whole variable.
2. Moving a partial path like a.b.c is ignored.
3. Reinitializing through a field (e.g. a.b.c = 5) counds as a reinitialization of all of a.

Some examples:

Rule 1:

let mut a = (vec![0], vec![0]);
drop(a);
// `a` is not considered initialized.

Rule 2:

let mut a = (vec![0], vec![0]);
drop(a.0);
drop(a.1);
// `a` is still considered initialized.

Rule 3:

let mut a = (vec![0], vec![0]);
drop(a);
a.1 = vec![1];
// all of `a` is considered initialized

Fields

hir: Map<'tcx>

places: ConsumedAndBorrowedPlaces

drop_ranges: DropRangesBuilder

expr_index: PostOrderId

tcx: TyCtxt<'tcx>

typeck_results: &'a TypeckResults<'tcx>

Implementations

impl<'a, 'tcx> DropRangeVisitor<'a, 'tcx>

fn new(
    hir: Map<'tcx>,
    tcx: TyCtxt<'tcx>,
    typeck_results: &'a TypeckResults<'tcx>,
    places: ConsumedAndBorrowedPlaces,
    num_exprs: usize
) -> Self

fn record_drop(&mut self, value: TrackedValue)

fn consume_expr(&mut self, expr: &Expr<'_>)

ExprUseVisitor’s consume callback doesn’t go deep enough for our purposes in all expressions. This method consumes a little deeper into the expression when needed.

fn reinit_expr(&mut self, expr: &Expr<'_>)

Marks an expression as being reinitialized.

Note that we always approximated on the side of things being more initialized than they actually are, as opposed to less. In cases such as x.y = ..., we would consider all of x as being initialized instead of just the y field.

This is because it is always safe to consider something initialized even when it is not, but the other way around will cause problems.

In the future, we will hopefully tighten up these rules to be more precise.

fn handle_uninhabited_return(&mut self, expr: &Expr<'tcx>)

For an expression with an uninhabited return type (e.g. a function that returns !), this adds a self edge to to the CFG to model the fact that the function does not return.

Trait Implementations

impl<'a, 'tcx> Visitor<'tcx> for DropRangeVisitor<'a, 'tcx>

fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>)

fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>)

type Map: Map<'v> = <Self::NestedFilter as NestedFilter<'v>>::Map

type NestedFilter: NestedFilter<'v> = None

fn nested_visit_map(&mut self) -> Self::Map

The default versions of the visit_nested_XXX routines invoke this method to get a map to use. By selecting an enum variant, you control which kinds of nested HIR are visited; see NestedVisitorMap for details. By “nested HIR”, we are referring to bits of HIR that are not directly embedded within one another but rather indirectly, through a table in the crate. This is done to control dependencies during incremental compilation: the non-inline bits of HIR can be tracked and hashed separately.

fn visit_nested_item(&mut self, id: ItemId)

Invoked when a nested item is encountered. By default does nothing unless you override nested_visit_map to return other than None, in which case it will walk the item. You probably don’t want to override this method – instead, override nested_visit_map or use the “shallow” or “deep” visit patterns described on itemlikevisit::ItemLikeVisitor. The only reason to override this method is if you want a nested pattern but cannot supply a Map; see nested_visit_map for advice.

fn visit_nested_trait_item(&mut self, id: TraitItemId)

Like visit_nested_item(), but for trait items. See visit_nested_item() for advice on when to override this method.

fn visit_nested_impl_item(&mut self, id: ImplItemId)

Like visit_nested_item(), but for impl items. See visit_nested_item() for advice on when to override this method.

fn visit_nested_foreign_item(&mut self, id: ForeignItemId)

Like visit_nested_item(), but for foreign items. See visit_nested_item() for advice on when to override this method.

fn visit_nested_body(&mut self, id: BodyId)

Invoked to visit the body of a function, method or closure. Like visit_nested_item, does nothing by default unless you override nested_visit_map to return other than None, in which case it will walk the body.

fn visit_param(&mut self, param: &'v Param<'v>)

fn visit_item(&mut self, i: &'v Item<'v>)

Visits the top-level item and (optionally) nested items / impl items. See visit_nested_item for details.

fn visit_body(&mut self, b: &'v Body<'v>)

fn as_deep_visitor(&mut self) -> DeepVisitor<'_, Self>

When invoking visit_all_item_likes(), you need to supply an item-like visitor. This method converts an “intra-visit” visitor into an item-like visitor that walks the entire tree. If you use this, you probably don’t want to process the contents of nested item-like things, since the outer loop will visit them as well.

fn visit_id(&mut self, _hir_id: HirId)

fn visit_name(&mut self, _span: Span, _name: Symbol)

fn visit_ident(&mut self, ident: Ident)

fn visit_mod(&mut self, m: &'v Mod<'v>, _s: Span, n: HirId)

fn visit_foreign_item(&mut self, i: &'v ForeignItem<'v>)

fn visit_local(&mut self, l: &'v Local<'v>)

fn visit_block(&mut self, b: &'v Block<'v>)

fn visit_stmt(&mut self, s: &'v Stmt<'v>)

fn visit_arm(&mut self, a: &'v Arm<'v>)

fn visit_array_length(&mut self, len: &'v ArrayLen)

fn visit_anon_const(&mut self, c: &'v AnonConst)

fn visit_let_expr(&mut self, lex: &'v Let<'v>)

fn visit_ty(&mut self, t: &'v Ty<'v>)

fn visit_generic_param(&mut self, p: &'v GenericParam<'v>)

fn visit_const_param_default(&mut self, _param: HirId, ct: &'v AnonConst)

fn visit_generics(&mut self, g: &'v Generics<'v>)

fn visit_where_predicate(&mut self, predicate: &'v WherePredicate<'v>)

fn visit_fn_decl(&mut self, fd: &'v FnDecl<'v>)

fn visit_fn(
    &mut self,
    fk: FnKind<'v>,
    fd: &'v FnDecl<'v>,
    b: BodyId,
    s: Span,
    id: HirId
)

fn visit_use(&mut self, path: &'v Path<'v>, hir_id: HirId)

fn visit_trait_item(&mut self, ti: &'v TraitItem<'v>)

fn visit_trait_item_ref(&mut self, ii: &'v TraitItemRef)

fn visit_impl_item(&mut self, ii: &'v ImplItem<'v>)

fn visit_foreign_item_ref(&mut self, ii: &'v ForeignItemRef)

fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef)

fn visit_trait_ref(&mut self, t: &'v TraitRef<'v>)

fn visit_param_bound(&mut self, bounds: &'v GenericBound<'v>)

fn visit_poly_trait_ref(
    &mut self,
    t: &'v PolyTraitRef<'v>,
    m: TraitBoundModifier
)

fn visit_variant_data(
    &mut self,
    s: &'v VariantData<'v>,
    Symbol,
    &'v Generics<'v>,
    _parent_id: HirId,
    Span
)

fn visit_field_def(&mut self, s: &'v FieldDef<'v>)

fn visit_enum_def(
    &mut self,
    enum_definition: &'v EnumDef<'v>,
    generics: &'v Generics<'v>,
    item_id: HirId,
    Span
)

fn visit_variant(
    &mut self,
    v: &'v Variant<'v>,
    g: &'v Generics<'v>,
    item_id: HirId
)

fn visit_label(&mut self, label: &'v Label)

fn visit_infer(&mut self, inf: &'v InferArg)

fn visit_generic_arg(&mut self, generic_arg: &'v GenericArg<'v>)

fn visit_lifetime(&mut self, lifetime: &'v Lifetime)

fn visit_qpath(&mut self, qpath: &'v QPath<'v>, id: HirId, span: Span)

fn visit_path(&mut self, path: &'v Path<'v>, _id: HirId)

fn visit_path_segment(
    &mut self,
    path_span: Span,
    path_segment: &'v PathSegment<'v>
)

fn visit_generic_args(
    &mut self,
    path_span: Span,
    generic_args: &'v GenericArgs<'v>
)

fn visit_assoc_type_binding(&mut self, type_binding: &'v TypeBinding<'v>)

fn visit_attribute(&mut self, _id: HirId, _attr: &'v Attribute)

fn visit_vis(&mut self, vis: &'v Spanned<VisibilityKind<'v>>)

fn visit_associated_item_kind(&mut self, kind: &'v AssocItemKind)

fn visit_defaultness(&mut self, defaultness: &'v Defaultness)

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: 208 bytes