Struct Analyzer 

struct Analyzer<'gcx> {
    gcx: Gcx<'gcx>,
    state: State,
    loop_exits: Vec<Vec<State>>,
    written: HashSet<VariableId>,
    hits: Vec<(Span, &'static SolLint)>,
}

Fields

gcx: Gcx<'gcx>

state: State

Gates the using ... for address sink form on a Solady-shaped library being present.

loop_exits: Vec<Vec<State>>

States at break/continue of each enclosing loop, innermost last.

written: HashSet<VariableId>

Every variable written on any path.

hits: Vec<(Span, &'static SolLint)>

Implementations

impl<'gcx> Analyzer<'gcx>

fn new(gcx: Gcx<'gcx>) -> Self

fn seed_immutable_facts(&mut self, cid: ContractId)

Seeds facts about immutable/constant state of cid from declaration initializers and the constructor body.

fn seed_callsite_facts(&mut self, func: &'gcx Function<'gcx>)

Seeds parameters of an internal function or modifier that every invocation site in the compilation unit passes a safe argument for.

fn hoist_modifier_facts(&mut self, m: &'gcx Modifier<'gcx>)

Hoists require(param == msg.sender | address(this)) guards from the prefix of modifier m onto the caller’s argument variables.

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

msg.sender, address(this) or a tracked-safe variable.

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

address(this) or a tracked self alias.

fn is_safe_target(&self, v: VariableId) -> bool

fn canonical(&self, v: VariableId) -> VariableId

Follows the alias chain to its root; bounded to guard against cycles.

fn canonical_key(&self, key: TokenKey) -> TokenKey

fn invalidate(&mut self, v: VariableId)

Drops every fact about v.

fn eval_rhs(&self, rhs: Option<&Expr<'_>>) -> Rhs

fn assign_var(&mut self, target: VariableId, rhs: Rhs)

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

Handles single and tuple LHS; rhs == None is an unknown value (delete).

fn add_facts(&mut self, pred: &Expr<'_>, negate: bool)

Records variables proven safe by pred (!pred when negate).

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

EIP-2612 token.permit(owner, <self>, ...) or the OpenZeppelin-style wrapper Lib.safePermit(token, owner, <self>, ...).

fn permit_covers(&self, sink: &Sink<'_>) -> bool

fn amount_matches( &self, expr: &Expr<'_>, amount: VariableId, fee: VariableId, ) -> bool

expr is amount + fee (either order), or a local bound to that sum.

fn consume_repayment(&mut self, sink: &Sink<'_>) -> bool

Consumes one pending repayment matched by a sink pulling amount + fee from the flash-loan receiver back to address(this).

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

Visits stmts up to the first that cannot fall through; returns whether the end is reachable.

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

Visits stmt, returning whether control can fall through it.

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_stmt(&mut self, stmt: &'gcx Stmt<'gcx>) -> ControlFlow<Never>

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_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: 392 bytes