Struct StepMap 

pub struct StepMap { /* private fields */ }

Per-step source locations and frame depths over one trace.

Implementations

impl StepMap

pub fn new(trace: &TransactionTrace, contracts: Vec<ContractDebugInfo>) -> Self

Maps every step of trace through the contracts’ debug info.

The root frame executes the transaction’s target, or the created contract for a deployment. A contract given with an address describes any frame that executes it; when only one contract is given, it also describes the root whatever address it names, so a single --ethdebug-dir applies to the transaction it was passed for.

pub fn for_debug_diff( trace: &TransactionTrace, contracts: Vec<ContractDebugInfo>, ) -> Self

Keeps single-instruction source stops when testing compiler debug information.

Interactive stepping smooths brief line excursions. A compiler regression test must observe them: an optimized getter can map its entire body to one SLOAD.

pub fn contracts(&self) -> &[ContractDebugInfo]

pub fn contract_at_step(&self, step: usize) -> Option<&ContractDebugInfo>

The contract whose code the step executes, when its debug info was loaded.

pub fn step_count(&self) -> usize

pub fn has_source(&self) -> bool

Whether any step maps to a source line at all.

pub fn line_key(&self, step: usize) -> Option<LineKey>

The line a step counts as for stepping and breakpoints.

pub fn frame_depth(&self, step: usize) -> Option<u32>

pub fn is_line_start(&self, step: usize) -> bool

pub fn is_frame_entry(&self, step: usize) -> bool

pub fn function_id(&self, step: usize) -> Option<FunctionId>

The function the step runs in, including generated code for one of its statements.

pub fn executing_address(&self, step: usize) -> Option<&str>

The address whose code the step executes, when it could be determined.

pub fn storage_address(&self, step: usize) -> Option<&str>

The account whose storage the step reads and writes: the executing address, or the caller’s under a DELEGATECALL.

pub fn storage_context_index(&self, step: usize) -> Option<usize>

An opaque identifier for that account, for indexing storage by context.

pub fn reverted_spans(&self) -> &[(usize, usize)]

Every EVM frame that reverted, as the step it was entered at and the step it reverted on. A frame’s writes, and its callees’, do not survive it.

pub fn argument_layout(&self, contract: usize) -> Option<ArgumentLayout>

What this trace proved about where a contract’s compiler leaves function parameters on the stack. None when the trace carried no frame that could show it, or when a frame contradicted it.

pub fn frame_arguments( &self, frame: &Frame, state: FrameState<'_>, ) -> Vec<FrameArgument>

The arguments frame was entered with, given the stack at its entry step.

Only a frame entered at its function’s entry point carries them, and only once this trace has shown that the compiler leaves them there: which word is which parameter depends on the code generator, and a legacy public function is entered through a dispatcher wrapper that has not decoded them yet. See StepMap::argument_layout.

pub fn location(&self, step: usize) -> Option<StepLocation>

pub fn next_source(&self, step: usize) -> Option<usize>

The step where the next source line begins at this frame or a caller’s, stepping over calls. None when the recording ends first.

Steps the compiler attached no source to, such as generated helper code, never stop a line step at the same depth: they belong to whatever line is executing.

From code outside every function, such as the dispatcher, this enters the function it jumps to instead of stepping over it: there is no caller to come back to, and a user at the first step wants to reach the first line, not the last.

pub fn step_into(&self, step: usize) -> Option<usize>

The step where the next source line begins anywhere, entering calls. A call into code without source stops at its first step, so the user sees where they are.

pub fn finish(&self, step: usize) -> Option<usize>

The step where the current frame has returned to its caller.

pub fn previous_source(&self, step: usize) -> Option<usize>

The start of the previous source line at this frame or a caller’s, skipping the calls it made. From the middle of a line this is the start of that line. From code outside every function it enters the function that just returned, the mirror of StepMap::next_source.

pub fn reverse_step_into(&self, step: usize) -> Option<usize>

The start of the previous source line anywhere, entering the calls it made.

pub fn reverse_finish(&self, step: usize) -> Option<usize>

The step in the caller that entered the current frame.

pub fn resolve_line( &self, file: Option<&str>, line: u64, ) -> Result<Vec<ResolvedLine>, String>

Resolves a file:line breakpoint against every loaded source. With no file, the line must be unambiguous across the loaded sources.

pub fn resolve_function( &self, name: &str, ) -> Result<Vec<ResolvedFunction>, String>

Resolves a function breakpoint by name, optionally qualified as Contract.function.

pub fn frames(&self, step: usize) -> Vec<Frame>

The call structure at step, innermost frame first.

pub fn source_listing(&self, step: usize, radius: u64) -> Option<SourceListing>

The source around step: radius lines on each side of its line.

Trait Implementations

impl Clone for StepMap

fn clone(&self) -> StepMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StepMap

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for StepMap

impl PartialEq for StepMap

fn eq(&self, other: &StepMap) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for StepMap