Struct rustc_passes::liveness::Liveness

pub(in liveness) struct Liveness<'a, 'tcx> {
    ir: &'a mut IrMaps<'tcx>,
    body_owner: LocalDefId,
    typeck_results: &'a TypeckResults<'tcx>,
    param_env: ParamEnv<'tcx>,
    upvars: Option<&'tcx FxIndexMap<HirId, Upvar>>,
    closure_captures: Option<&'tcx FxIndexMap<HirId, UpvarId>>,
    successors: IndexVec<LiveNode, Option<LiveNode>>,
    rwu_table: RWUTable,
    closure_ln: LiveNode,
    exit_ln: LiveNode,
    break_ln: HirIdMap<LiveNode>,
    cont_ln: HirIdMap<LiveNode>,
}

Fields

ir: &'a mut IrMaps<'tcx>

body_owner: LocalDefId

typeck_results: &'a TypeckResults<'tcx>

param_env: ParamEnv<'tcx>

upvars: Option<&'tcx FxIndexMap<HirId, Upvar>>

closure_captures: Option<&'tcx FxIndexMap<HirId, UpvarId>>

successors: IndexVec<LiveNode, Option<LiveNode>>

rwu_table: RWUTable

closure_ln: LiveNode

A live node representing a point of execution before closure entry & after closure exit. Used to calculate liveness of captured variables through calls to the same closure. Used for Fn & FnMut closures only.

exit_ln: LiveNode

A live node representing every 'exit' from the function, whether it be by explicit return, panic, or other means.

break_ln: HirIdMap<LiveNode>

cont_ln: HirIdMap<LiveNode>

Implementations

impl<'a, 'tcx> Liveness<'a, 'tcx>

pub(in liveness) fn new(
    ir: &'a mut IrMaps<'tcx>,
    body_owner: LocalDefId
) -> Liveness<'a, 'tcx>

pub(in liveness) fn live_node(
    &self,
    hir_id: HirId,
    span: Span
) -> LiveNode

pub(in liveness) fn variable(
    &self,
    hir_id: HirId,
    span: Span
) -> Variable

pub(in liveness) fn define_bindings_in_pat(
    &mut self,
    pat: &Pat<'_>,
    succ: LiveNode
) -> LiveNode

pub(in liveness) fn idx(
    &self,
    ln: LiveNode,
    var: Variable
) -> usize

pub(in liveness) fn live_on_entry(
    &self,
    ln: LiveNode,
    var: Variable
) -> Option<LiveNodeKind>

pub(in liveness) fn live_on_exit(
    &self,
    ln: LiveNode,
    var: Variable
) -> Option<LiveNodeKind>

pub(in liveness) fn used_on_entry(
    &self,
    ln: LiveNode,
    var: Variable
) -> bool

pub(in liveness) fn assigned_on_entry(
    &self,
    ln: LiveNode,
    var: Variable
) -> Option<LiveNodeKind>

pub(in liveness) fn assigned_on_exit(
    &self,
    ln: LiveNode,
    var: Variable
) -> Option<LiveNodeKind>

pub(in liveness) fn indices2<F>(
    &mut self,
    ln: LiveNode,
    succ_ln: LiveNode,
    op: F
) where
    F: FnMut(&mut Liveness<'a, 'tcx>, usize, usize), 

pub(in liveness) fn write_vars<F>(
    &self,
    wr: &mut dyn Write,
    ln: LiveNode,
    test: F
) -> Result<()> where
    F: FnMut(usize) -> bool, 

pub(in liveness) fn ln_str(
    &self,
    ln: LiveNode
) -> String

pub(in liveness) fn log_liveness(
    &self,
    entry_ln: LiveNode,
    hir_id: HirId
)

pub(in liveness) fn init_empty(
    &mut self,
    ln: LiveNode,
    succ_ln: LiveNode
)

pub(in liveness) fn init_from_succ(
    &mut self,
    ln: LiveNode,
    succ_ln: LiveNode
)

pub(in liveness) fn merge_from_succ(
    &mut self,
    ln: LiveNode,
    succ_ln: LiveNode,
    first_merge: bool
) -> bool

pub(in liveness) fn define(
    &mut self,
    writer: LiveNode,
    var: Variable
)

pub(in liveness) fn acc(
    &mut self,
    ln: LiveNode,
    var: Variable,
    acc: u32
)

pub(in liveness) fn compute(
    &mut self,
    body: &Body<'_>,
    hir_id: HirId
) -> LiveNode

pub(in liveness) fn propagate_through_block(
    &mut self,
    blk: &Block<'_>,
    succ: LiveNode
) -> LiveNode

pub(in liveness) fn propagate_through_stmt(
    &mut self,
    stmt: &Stmt<'_>,
    succ: LiveNode
) -> LiveNode

pub(in liveness) fn propagate_through_exprs(
    &mut self,
    exprs: &[Expr<'_>],
    succ: LiveNode
) -> LiveNode

pub(in liveness) fn propagate_through_opt_expr(
    &mut self,
    opt_expr: Option<&Expr<'_>>,
    succ: LiveNode
) -> LiveNode

pub(in liveness) fn propagate_through_expr(
    &mut self,
    expr: &Expr<'_>,
    succ: LiveNode
) -> LiveNode

pub(in liveness) fn propagate_through_place_components(
    &mut self,
    expr: &Expr<'_>,
    succ: LiveNode
) -> LiveNode

pub(in liveness) fn write_place(
    &mut self,
    expr: &Expr<'_>,
    succ: LiveNode,
    acc: u32
) -> LiveNode

pub(in liveness) fn access_var(
    &mut self,
    hir_id: HirId,
    var_hid: HirId,
    succ: LiveNode,
    acc: u32,
    span: Span
) -> LiveNode

pub(in liveness) fn access_path(
    &mut self,
    hir_id: HirId,
    path: &Path<'_>,
    succ: LiveNode,
    acc: u32
) -> LiveNode

pub(in liveness) fn propagate_through_loop(
    &mut self,
    expr: &Expr<'_>,
    body: &Block<'_>,
    succ: LiveNode
) -> LiveNode

impl<'tcx, '_> Liveness<'_, 'tcx>

pub(in liveness) fn check_place(
    &mut self,
    expr: &'tcx Expr<'tcx>
)

pub(in liveness) fn should_warn(
    &self,
    var: Variable
) -> Option<String>

pub(in liveness) fn warn_about_unused_upvars(
    &self,
    entry_ln: LiveNode
)

pub(in liveness) fn warn_about_unused_args(
    &self,
    body: &Body<'_>,
    entry_ln: LiveNode
)

pub(in liveness) fn check_unused_vars_in_pat(
    &self,
    pat: &Pat<'_>,
    entry_ln: Option<LiveNode>,
    on_used_on_entry: impl Fn(Vec<Span>, HirId, LiveNode, Variable)
)

pub(in liveness) fn report_unused(
    &self,
    hir_ids_and_spans: Vec<(HirId, Span)>,
    ln: LiveNode,
    var: Variable
)

pub(in liveness) fn warn_about_dead_assign(
    &self,
    spans: Vec<Span>,
    hir_id: HirId,
    ln: LiveNode,
    var: Variable
)

pub(in liveness) fn report_unsed_assign(
    &self,
    hir_id: HirId,
    spans: Vec<Span>,
    var: Variable,
    message: impl Fn(&str) -> String
)

Trait Implementations

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

type Map = ErasedMap<'tcx>

pub fn nested_visit_map(&mut self) -> NestedVisitorMap<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.

pub fn visit_local(&mut self, local: &'tcx Local<'tcx>)

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

pub fn visit_arm(&mut self, arm: &'tcx Arm<'tcx>)

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

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

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

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

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

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

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

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

pub fn visit_id(&mut self, _hir_id: HirId)

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

pub fn visit_ident(&mut self, ident: Ident)

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

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

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

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

pub fn visit_pat(&mut self, p: &'v Pat<'v>)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn visit_struct_field(&mut self, s: &'v StructField<'v>)

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

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

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

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

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

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

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

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

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

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

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

pub fn visit_macro_def(&mut self, macro_def: &'v MacroDef<'v>)

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

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

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