Struct Analyzer 

struct Analyzer<'gcx> {
    gcx: Gcx<'gcx>,
    returns: &'gcx [VariableId],
    state: FlowState,
    next_value: u32,
    hits: Vec<Span>,
    deferred: HashMap<ExprId, Option<PendingRecovery>>,
    loop_exits: Vec<FlowState>,
    loop_next: Option<&'gcx Stmt<'gcx>>,
}

Fields

gcx: Gcx<'gcx>

returns: &'gcx [VariableId]

state: FlowState

next_value: u32

hits: Vec<Span>

deferred: HashMap<ExprId, Option<PendingRecovery>>

ecrecover calls whose result is being stored into a local. Their recovery is captured here instead of being reported at the call site.

loop_exits: Vec<FlowState>

States reaching break/continue or the end of the innermost loop body.

loop_next: Option<&'gcx Stmt<'gcx>>

Update statement of the innermost for loop, which continue still executes.

Implementations

impl<'gcx> Analyzer<'gcx>

const fn fresh_value(&mut self) -> ValueId

fn join(&mut self, left: FlowState, right: FlowState) -> FlowState

fn join_all(&mut self, states: Vec<FlowState>) -> bool

Continues from the join of states; returns false when no path continues.

fn emit_hit(&mut self, span: Span)

fn use_value(&mut self, value: ValueId)

fn use_return_values(&mut self)

fn use_all_pending(&mut self)

fn validate_pending(&mut self)

Drops pending recoveries whose signature has since been proven canonical.

fn current_value(&self, expr: &Expr<'_>) -> Option<ValueId>

fn place_key(&self, expr: &Expr<'_>) -> Option<ValueKey>

The tracked place an expression denotes: a variable or a var.field member, through parens and uint256(..)/bytes32(..) casts.

fn reference_args( &self, callee: &'gcx Expr<'gcx>, args: &'gcx CallArgs<'gcx>, ) -> Vec<VariableId>

Memory and storage variables passed by reference to an internal function (including the receiver of a using for call), which the callee may write through.

fn is_local(&self, var: VariableId) -> bool

fn ecrecover_call( &self, expr: &'gcx Expr<'gcx>, ) -> Option<(&'gcx Expr<'gcx>, &'gcx Expr<'gcx>)>

The call expression and signature argument of a builtin ecrecover call.

fn pending_recovery(&self, expr: &'gcx Expr<'gcx>) -> Option<PendingRecovery>

fn live_arms<T>( &self, cond: &Expr<'_>, then: T, otherwise: T, ) -> impl Iterator<Item = T>

The arms of cond ? then : otherwise that may execute.

fn result_calls(&self, expr: &'gcx Expr<'gcx>, out: &mut Vec<ExprId>)

ecrecover calls whose result becomes the value of expr.

fn const_value(&self, expr: &Expr<'_>) -> Option<U256>

fn const_bool(&self, expr: &Expr<'_>) -> Option<bool>

fn is_proven_low_s(&self, expr: &'gcx Expr<'gcx>) -> bool

fn assigned(&self, rhs: Option<&'gcx Expr<'gcx>>) -> (Option<ValueId>, bool)

The (value, proven low) a variable takes when assigned rhs.

fn assign(&mut self, key: ValueKey, (value, low_s): (Option<ValueId>, bool))

fn aliasable_location(&self, var: VariableId) -> Option<DataLocation>

The data location through which var may alias other variables.

fn pairs( &self, lhs: &'gcx Expr<'gcx>, rhs: Option<&'gcx Expr<'gcx>>, out: &mut Vec<(Option<ValueKey>, Option<&'gcx Expr<'gcx>>)>, )

Pairs every place written by lhs with the expression it receives.

fn assign_pairs( &mut self, pairs: &[(Option<ValueKey>, Option<&'gcx Expr<'gcx>>)], )

Assigns every pair, reading all right-hand sides first so tuple swaps are exact.

fn assign_lhs(&mut self, lhs: &'gcx Expr<'gcx>, rhs: Option<&'gcx Expr<'gcx>>)

fn store( &mut self, pairs: &[(Option<ValueKey>, Option<&'gcx Expr<'gcx>>)], rhs: Option<&'gcx Expr<'gcx>>, )

Models a statement-level store of rhs into pairs. Recoveries stored into locals stay pending until the local is read or the signature validated; any other destination observes the result immediately.

fn store_expr(&mut self, lhs: &'gcx Expr<'gcx>, rhs: &'gcx Expr<'gcx>)

fn visit_lhs(&mut self, lhs: &'gcx Expr<'gcx>)

Visits an lvalue without treating the written variables as reads.

fn invalidate_mutable_state(&mut self)

Forgets mutable state variables and storage pointers, which any state-mutating call may have written.

fn has_side_effect(&self, expr: &'gcx Expr<'gcx>) -> bool

fn assume(&mut self, predicate: &'gcx Expr<'gcx>, negate: bool)

fn add_facts(&mut self, predicate: &'gcx Expr<'gcx>, negate: bool)

fn branch( &mut self, cond: &'gcx Expr<'gcx>, then: impl FnOnce(&mut Self) -> bool, otherwise: impl FnOnce(&mut Self) -> bool, ) -> bool

Runs then and otherwise under the respective assumptions on the already visited cond, then continues from the join of the arms that did not exit.

fn run_block(&mut self, stmts: &'gcx [Stmt<'gcx>]) -> bool

fn run_stmt(&mut self, stmt: &'gcx Stmt<'gcx>) -> bool

Runs stmt; returns false when control cannot continue past it.

fn run_loop( &mut self, block: &'gcx Block<'gcx>, source: LoopSource<'gcx>, ) -> bool

fn run_loop_body(&mut self, block: &'gcx Block<'gcx>)

Trait Implementations

impl<'gcx> Visit<'gcx> for Analyzer<'gcx>

type BreakValue = <fn() -> ! as GetReturnType>::ReturnType

The value returned when breaking from the traversal.

fn hir(&self) -> &'gcx Hir<'gcx>

Returns the HIR map.

fn visit_expr(&mut self, expr: &'gcx Expr<'gcx>) -> ControlFlow<Never>

fn visit_nested_source(&mut self, id: SourceId) -> ControlFlow<Self::BreakValue>

fn visit_nested_item(&mut self, id: ItemId) -> ControlFlow<Self::BreakValue>

fn visit_item( &mut self, item: Item<'hir, 'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_nested_contract( &mut self, id: ContractId, ) -> ControlFlow<Self::BreakValue>

fn visit_contract( &mut self, contract: &'hir Contract<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_nested_function( &mut self, id: FunctionId, ) -> ControlFlow<Self::BreakValue>

fn visit_function( &mut self, func: &'hir Function<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_modifier( &mut self, modifier: &'hir Modifier<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_nested_struct(&mut self, id: StructId) -> ControlFlow<Self::BreakValue>

fn visit_struct( &mut self, strukt: &'hir Struct<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_nested_enum(&mut self, id: EnumId) -> ControlFlow<Self::BreakValue>

fn visit_enum( &mut self, enumm: &'hir Enum<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_nested_udvt(&mut self, id: UdvtId) -> ControlFlow<Self::BreakValue>

fn visit_udvt( &mut self, udvt: &'hir Udvt<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_nested_error(&mut self, id: ErrorId) -> ControlFlow<Self::BreakValue>

fn visit_error( &mut self, error: &'hir Error<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_nested_event(&mut self, id: EventId) -> ControlFlow<Self::BreakValue>

fn visit_event( &mut self, event: &'hir Event<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_nested_var(&mut self, id: VariableId) -> ControlFlow<Self::BreakValue>

fn visit_var( &mut self, var: &'hir Variable<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_call_args( &mut self, args: &'hir CallArgs<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_stmt( &mut self, stmt: &'hir Stmt<'hir>, ) -> ControlFlow<Self::BreakValue>

fn visit_ty(&mut self, ty: &'hir Type<'hir>) -> ControlFlow<Self::BreakValue>

fn walk_nested_source(&mut self, id: SourceId) -> ControlFlow<Self::BreakValue>

fn walk_nested_item(&mut self, id: ItemId) -> ControlFlow<Self::BreakValue>

fn walk_item(&mut self, item: Item<'hir, 'hir>) -> ControlFlow<Self::BreakValue>

fn walk_nested_contract( &mut self, id: ContractId, ) -> ControlFlow<Self::BreakValue>

fn walk_contract( &mut self, contract: &'hir Contract<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_nested_function( &mut self, id: FunctionId, ) -> ControlFlow<Self::BreakValue>

fn walk_function( &mut self, func: &'hir Function<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_modifier( &mut self, modifier: &'hir Modifier<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_nested_struct(&mut self, id: StructId) -> ControlFlow<Self::BreakValue>

fn walk_struct( &mut self, strukt: &'hir Struct<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_nested_enum(&mut self, id: EnumId) -> ControlFlow<Self::BreakValue>

fn walk_enum( &mut self, enumm: &'hir Enum<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_nested_udvt(&mut self, id: UdvtId) -> ControlFlow<Self::BreakValue>

fn walk_udvt(&mut self, udvt: &'hir Udvt<'hir>) -> ControlFlow<Self::BreakValue>

fn walk_nested_error(&mut self, id: ErrorId) -> ControlFlow<Self::BreakValue>

fn walk_error( &mut self, error: &'hir Error<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_nested_event(&mut self, id: EventId) -> ControlFlow<Self::BreakValue>

fn walk_event( &mut self, event: &'hir Event<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_nested_var(&mut self, id: VariableId) -> ControlFlow<Self::BreakValue>

fn walk_var( &mut self, var: &'hir Variable<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_expr(&mut self, expr: &'hir Expr<'hir>) -> ControlFlow<Self::BreakValue>

fn walk_call_args( &mut self, args: &'hir CallArgs<'hir>, ) -> ControlFlow<Self::BreakValue>

fn walk_stmt(&mut self, stmt: &'hir Stmt<'hir>) -> ControlFlow<Self::BreakValue>

fn walk_ty(&mut self, ty: &'hir Type<'hir>) -> ControlFlow<Self::BreakValue>

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