Struct Cx 

struct Cx<'gcx> {
    gcx: Gcx<'gcx>,
}

The analysis context.

Fields

gcx: Gcx<'gcx>

Implementations

impl<'gcx> Cx<'gcx>

fn is_override_delegation_helper(self, function: &'gcx Function<'gcx>) -> bool

Whether an internal/private function is reached from a user _mint override of a derived contract, making it part of the mint primitive rather than a call site.

fn function_reaches( self, function_id: FunctionId, target: FunctionId, seen: &mut Vec<FunctionId>, ) -> bool

Whether function_id calls target, directly or through internal functions.

fn unsafe_mint_target( self, function_id: FunctionId, helper: bool, seen: &mut Vec<FunctionId>, ) -> Option<UnsafeMintTarget>

Whether function_id is a _mint whose execution skips the receiver check: the canonical OZ declaration (exact OZ contract name AND an OpenZeppelin source path, so a local contract reusing a name like ERC721Consecutive stays out), or a user override whose body calls a _mint that is itself unsafe (the capped/pausable pattern forwarding through super._mint). An override whose successful paths prove the recipient code-less or reject it after the delegation is a safe wrapper like canonical _safeMint. seen cuts override cycles, which never reach the canonical declaration.

fn any_in_stmts( self, stmts: &'gcx [Stmt<'gcx>], stmt_matches: impl FnMut(&'gcx Stmt<'gcx>) -> bool, expr_matches: impl FnMut(&'gcx Expr<'gcx>) -> bool, ) -> bool

Runs stmt_matches/expr_matches over a subtree and reports whether either held.

fn any_in_expr( self, expr: &'gcx Expr<'gcx>, expr_matches: impl FnMut(&'gcx Expr<'gcx>) -> bool, ) -> bool

fn calls( self, stmts: &'gcx [Stmt<'gcx>], ) -> Vec<(FunctionId, &'gcx CallArgs<'gcx>, Span)>

Every resolved call in a subtree, in source order.

fn resolved_callee(self, expr: &Expr<'_>) -> Option<FunctionId>

The function a call expression dispatches to, as the type checker resolved it.

fn callee_fn(self, expr: &Expr<'_>) -> Option<&'gcx TyFn<'gcx>>

fn resolved_internal_callee(self, expr: &Expr<'_>) -> Option<FunctionId>

The declaration a call executes in the current EVM frame. A public function called by name is internal here, while this.f() and other external calls run in another frame whose assembly return cannot bypass the caller’s later statements.

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

Whether a call dispatches through an internal function-pointer variable whose target is not available from the callee type. Such a target may contain assembly that leaves the frame, so exit analysis must treat the call conservatively.

fn arg( self, function_id: FunctionId, args: &'gcx CallArgs<'gcx>, index: usize, ) -> Option<&'gcx Expr<'gcx>>

The argument a call binds to the callee’s parameter at index, positional or named.

fn is_receiver_hook(self, function_id: FunctionId) -> bool

Whether a resolved declaration is the ERC721 receiver hook: the exact name, the exact (address, address, uint256, bytes) shape, and an externally callable declaration of a non-library contract. A same-name function of an unrelated interface answers on a different selector, and an attached library or free function runs in the minting contract without any external call.

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

Whether an expression is the accepting answer, onERC721Received’s selector: the literal, a conversion of it, a constant holding it, or a selector member resolving to the receiver hook itself. The member is resolved rather than matched by name: spelled on a same-name function of another shape, .selector is a different value. An immutable or a state variable is unknown here and does not exempt.

fn selector_cast_preserves(self, cast: &Expr<'_>, inner: &Expr<'_>) -> bool

Whether a cast preserves the recognized selector’s value and byte alignment. A recognized integer is exactly the positive selector, so any integer width of at least 32 bits keeps it. Fixed bytes are left-aligned while integers are right-aligned, so crossing between them is only trusted at the four-byte boundary.

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

Whether executing stmt always reverts, undoing everything the transaction did. Only a revert counts, see Self::may_return for the escapes that leave the transaction standing.

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

Whether a statement may leave the function while keeping what the transaction already did: a return, or the EVM return/stop an assembly block can hold. Only statements that provably cannot leave answer no.

fn contains_frame_ending_assembly( self, stmts: &'gcx [Stmt<'gcx>], seen: &mut Vec<FunctionId>, ) -> bool

Whether a subtree can reach an assembly block in the same EVM frame, directly or through an internal call. An assembly return leaves the frame without running a later revert or what an outer modifier holds after its placeholder. Every assembly block is treated as capable of doing so.

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

fn call_leaves_frame(self, expr: &Expr<'_>, seen: &mut Vec<FunctionId>) -> bool

fn callable_contains_frame_ending_assembly( self, function_id: FunctionId, seen: &mut Vec<FunctionId>, ) -> bool

Whether a same-frame callable or one of its applied modifiers can reach assembly. The recursion set is a path stack so independent calls are summarized independently.

fn mutates_var(self, stmt: &'gcx Stmt<'gcx>, var: VariableId) -> bool

Whether a statement assigns to var: var = x, var += x, var++, delete var, or var as a component of a tuple assignment. An assembly block is treated as an opaque assignment, since it can rewrite Solidity locals outside the HIR expression tree. Identity is by variable, not by value, so a guard that checked var says nothing once var is reassigned.

fn expr_mutates_var(self, expr: &'gcx Expr<'gcx>, var: VariableId) -> bool

fn stmts_may_change_account_code( self, stmts: &'gcx [Stmt<'gcx>], delegations: &[FunctionId], unstable_code_delegations: &[FunctionId], seen: &mut Vec<FunctionId>, ) -> bool

Whether a subtree may change the code installed at an account. Inline assembly is opaque and may deploy code even when it contains no HIR call expression.

fn expr_may_change_account_code( self, expr: &'gcx Expr<'gcx>, delegations: &[FunctionId], unstable_code_delegations: &[FunctionId], seen: &mut Vec<FunctionId>, ) -> bool

fn call_may_change_account_code( self, expr: &Expr<'_>, delegations: &[FunctionId], unstable_code_delegations: &[FunctionId], seen: &mut Vec<FunctionId>, ) -> bool

Whether a call may change the code installed at an account. Pure and view calls are stable (external ones execute through STATICCALL), while nonpayable/payable calls and contract creation can run CREATE/CREATE2. Calls to the delegated mint itself are excluded unless it is recursively unstable: the code-length proof is needed precisely until that call begins.

fn callable_may_change_account_code( self, function_id: FunctionId, seen: &mut Vec<FunctionId>, ) -> bool

Whether a statically known same-frame callable can create code, directly, through an applied modifier, or through another internal call. Recursion cycles alone do not create code; any opaque, virtual, or external state-changing call reached remains conservative.

fn bound_guard_parameters( self, function_id: FunctionId, args: &'gcx CallArgs<'gcx>, recipient: VariableId, token: VariableId, ) -> Option<(VariableId, VariableId)>

The callee parameters that receive the caller’s recipient and token identities.

fn body_guards( self, function_id: FunctionId, recipient: VariableId, token: VariableId, seen: &mut Vec<FunctionId>, ) -> GuardCoverage

Guard coverage a callee’s body establishes for the parameters the recipient and the token landed on: the callee guards when a guard ran before any possible successful exit. seen cuts recursion cycles.

fn modifier_coverage_at_body( self, function: &'gcx Function<'gcx>, recipient: VariableId, token: VariableId, seed: GuardCoverage, ) -> GuardWalk

Coverage in effect when a function body starts after expanding its modifiers in declaration order. Prefixes are walked in execution order so calls in an inner modifier can retire an outer code-length snapshot. A proven tail guard is represented as stable callback coverage while walking the body: it runs after the body and can revert every mint the body made, unless assembly in the body or an inner modifier can bypass it.

Trait Implementations

impl<'gcx> Clone for Cx<'gcx>

fn clone(&self) -> Cx<'gcx>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'gcx> Copy for Cx<'gcx>

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