Struct Analyzer 

struct Analyzer<'ctx, 's, 'c, 'gcx> {

    ctx: &'ctx LintContext<'s, 'c>,
    gcx: Gcx<'gcx>,
    emitted: HashSet<Span>,
    emitted_balance: HashSet<Span>,
    call_stack: Vec<FunctionId>,
    inline_cache: HelperAnalysisCache<InlineCallKey, (FlowState, Vec<BalanceValue>)>,
    recursive_cuts: HashMap<(FunctionId, BTreeSet<FunctionId>), Option<FunctionId>>,
    direct_internal_calls: HashMap<FunctionId, Vec<FunctionId>>,
    reentrancy_eth_enabled: bool,
    reentrancy_no_eth_enabled: bool,
    reentrancy_balance_enabled: bool,
    balance_only_analysis: bool,
    call_balance_values: HashMap<Span, Vec<BalanceValue>>,
    return_collectors: Vec<(FunctionId, Vec<BalanceValue>)>,
    active_balance_guards: Vec<VariableId>,
    balance_reentry_lock: Option<VariableId>,
}

Fields

ctx: &'ctx LintContext<'s, 'c>

gcx: Gcx<'gcx>

emitted: HashSet<Span>

emitted_balance: HashSet<Span>

call_stack: Vec<FunctionId>

inline_cache: HelperAnalysisCache<InlineCallKey, (FlowState, Vec<BalanceValue>)>

recursive_cuts: HashMap<(FunctionId, BTreeSet<FunctionId>), Option<FunctionId>>

First function on the given call stack reachable again from a callee, per callee.

direct_internal_calls: HashMap<FunctionId, Vec<FunctionId>>

reentrancy_eth_enabled: bool

reentrancy_no_eth_enabled: bool

reentrancy_balance_enabled: bool

balance_only_analysis: bool

Set while re-running code only to refine the balance analysis.

call_balance_values: HashMap<Span, Vec<BalanceValue>>

Balance facts about the return values of each analysed internal call site.

return_collectors: Vec<(FunctionId, Vec<BalanceValue>)>

Return-value accumulators of the internal calls currently being inlined.

active_balance_guards: Vec<VariableId>

Reentrancy-guard locks held by the modifiers wrapping the code being analysed.

balance_reentry_lock: Option<VariableId>

The lock guarding every entry point of each deployable contract, if any.

Implementations

impl<'ctx, 's, 'c, 'gcx> Analyzer<'ctx, 's, 'c, 'gcx>

fn new( ctx: &'ctx LintContext<'s, 'c>, gcx: Gcx<'gcx>, entry: &'gcx Function<'gcx>, ) -> Self

const fn has_enabled_lints(&self) -> bool

fn analyze_callable( &mut self, func: &'gcx Function<'gcx>, body: Block<'gcx>, state: &mut FlowState, ) -> bool

Analyses func (modifiers first, then body); returns whether it can fall through.

fn analyze_modifier_chain( &mut self, modifiers: &'gcx [Modifier<'gcx>], index: usize, body: Block<'gcx>, state: &mut FlowState, ) -> bool

fn analyze_iteration( &mut self, block: Block<'gcx>, source: LoopSource<'gcx>, placeholder: Option<(&'gcx [Modifier<'gcx>], usize, Block<'gcx>, Option<VariableId>)>, state: &mut FlowState, ) -> bool

Analyzes one loop iteration: the body, then the for update if the body completes.

fn analyze_block( &mut self, block: Block<'gcx>, placeholder: Option<(&'gcx [Modifier<'gcx>], usize, Block<'gcx>, Option<VariableId>)>, state: &mut FlowState, ) -> bool

fn analyze_stmt( &mut self, stmt: &'gcx Stmt<'gcx>, placeholder: Option<(&'gcx [Modifier<'gcx>], usize, Block<'gcx>, Option<VariableId>)>, state: &mut FlowState, ) -> bool

Analyses stmt; returns whether control can continue past it.

fn split_on( &self, cond: &'gcx Expr<'gcx>, then_state: &mut FlowState, else_state: &mut FlowState, ) -> (bool, bool)

Constrains the branch states of a conditional on cond; returns whether each is reachable.

fn analyze_expr(&mut self, expr: &'gcx Expr<'gcx>, state: &mut FlowState)

fn analyze_lhs_indices(&mut self, expr: &'gcx Expr<'gcx>, state: &mut FlowState)

Evaluates the index and slice operands of an lvalue; the written root itself is no read.

fn record_write(&mut self, lhs: &'gcx Expr<'gcx>, state: &mut FlowState)

Handles a write to lhs: reports pending reentrant calls that read the written state, invalidates written guard locks and forgets path facts about written locals.

fn analyze_internal_call( &mut self, func_id: FunctionId, args: &CallArgs<'gcx>, state: &mut FlowState, ) -> Vec<BalanceValue>

fn internal_callees( &self, callee: &'gcx Expr<'gcx>, state: &FlowState, ) -> BTreeSet<FunctionId>

Internal functions a call through callee may reach, following function-typed locals.

fn update_internal_function_target( &self, state: &mut FlowState, var_id: VariableId, value: &'gcx Expr<'gcx>, )

fn merge_call_balance_values(&mut self, span: Span, values: Vec<BalanceValue>)

fn analyze_with_only_balance<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T

fn first_recursive_cut(&mut self, func_id: FunctionId) -> Option<FunctionId>

fn first_recursive_cut_from( &mut self, func_id: FunctionId, active: &BTreeSet<FunctionId>, seen: &mut HashSet<FunctionId>, ) -> Option<FunctionId>

Depth-first search from func_id for the first callee that is currently active.

fn direct_internal_calls(&mut self, func_id: FunctionId) -> Vec<FunctionId>

Internal functions and modifiers func_id invokes directly.

fn emit_pending_calls(&mut self, state: &FlowState, written_vars: &[VariableId])

fn emit_balance_calls(&mut self, guard: &'gcx Expr<'gcx>, state: &FlowState)

Reports pending balance calls whose stale balance guard compares against.

fn guard_has_stale_balance_comparison( &self, expr: &'gcx Expr<'gcx>, span: Span, call: &BTreeSet<BTreeMap<PathPredicate, bool>>, state: &FlowState, ) -> bool

True if expr compares a balance read before the pending call against one read after.

fn bind_locals( &mut self, state: &mut FlowState, targets: &[Option<VariableId>], rhs: &'gcx Expr<'gcx>, op: Option<BinOpKind>, )

Binds the components of rhs to the local targets they are assigned to.

fn set_self_address_paths( &self, state: &mut FlowState, var_id: VariableId, paths: BTreeSet<BTreeMap<PathPredicate, bool>>, )

fn set_balance_local( &self, state: &mut FlowState, var_id: VariableId, value: &BalanceValue, op: Option<BinOpKind>, )

Makes var_id hold value; a compound assignment also keeps what the local held before.

fn balance_values( &self, rhs: &'gcx Expr<'gcx>, state: &FlowState, ) -> Vec<BalanceValue>

Balance facts of each component of rhs, one per destructuring target.

fn balance_dependency( &self, expr: &'gcx Expr<'gcx>, state: &FlowState, ) -> BalanceValue

fn self_address_path( &self, expr: &Expr<'_>, state: &FlowState, ) -> BTreeSet<BTreeMap<PathPredicate, bool>>

Predicates under which expr evaluates to address(this).

fn self_balance_paths( &self, expr: &Expr<'_>, state: &FlowState, ) -> BTreeSet<BTreeMap<PathPredicate, bool>>

Predicates under which expr is <self address>.balance.

fn expr_balance_paths( &self, expr: &'gcx Expr<'gcx>, state: &FlowState, ) -> BTreeSet<BTreeMap<PathPredicate, bool>>

Predicates under which expr derives from the contract’s own balance.

fn balance_operand_dependencies( &self, expr: &'gcx Expr<'gcx>, state: &FlowState, ) -> BTreeSet<BalanceForm>

Retains balance occurrences across comparison operands without assuming arithmetic identities.

fn balance_forms( &self, expr: &'gcx Expr<'gcx>, state: &FlowState, ) -> BTreeSet<BalanceForm>

Preserves balance terms through addition/subtraction and value-preserving integer casts. Other operators may form independent offsets, but cannot transform balance terms. Unsupported expressions return no forms, rather than an independent offset.

fn seed_balance_parameters( &mut self, func_id: FunctionId, args: &CallArgs<'gcx>, state: &mut FlowState, )

Binds the balance facts of the call arguments to the callee’s parameters.

fn clear_local(&self, state: &mut FlowState, var_id: VariableId)

fn record_return(&mut self, expr: Option<&'gcx Expr<'gcx>>, state: &FlowState)

Accumulates the values returned by return expr; (or the named return variables when the function falls through) into the innermost return collector.

fn local_value(&self, var_id: VariableId, state: &FlowState) -> BalanceValue

The balance facts currently recorded for the local var_id.

fn clear_function_locals(&self, func_id: FunctionId, state: &mut FlowState)

Drops every fact about locals of func_id once its inlined body is left.

fn reentrant_call_kind( &self, callee: &'gcx Expr<'gcx>, opts: Option<&CallOptions<'gcx>>, ) -> Option<ReentrantCallKind>

fn balance_guard_blocks_call( &self, state: &FlowState, callee: &'gcx Expr<'gcx>, ) -> bool

True if the contract-wide reentrancy lock is held and intact around the call.

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