Struct SourceAnalysis 

pub struct SourceAnalysis {

    pub id: u32,
    pub path: PathBuf,
    pub unit: SourceUnit,
    pub version_req: Option<VersionReq>,
    pub global_scope: VariableScopeRef,
    pub steps: Vec<StepRef>,
    pub private_state_variables: Vec<VariableRef>,
    pub contracts: Vec<ContractRef>,
    pub functions: Vec<FunctionRef>,
    pub state_variables: Vec<VariableRef>,
    pub private_functions: Vec<FunctionRef>,
    pub immutable_functions: Vec<FunctionRef>,
    pub function_types: Vec<FunctionTypeNameRef>,
    pub user_defined_types: Vec<UserDefinedTypeRef>,
}

Analysis results for a single source file.

Contains all the analysis data for one Solidity source file, including the original source content, parsed AST, and step-by-step analysis results.

Fields

• id: Unique identifier for this source file
• path: File system path to the source file
• source: Original source content and metadata
• ast: Parsed Abstract Syntax Tree
• unit: Processed source unit ready for analysis
• steps: List of analyzed execution steps in this file

Fields

id: u32

Unique identifier for this source file

path: PathBuf

File system path to the source file

unit: SourceUnit

Processed source unit ready for analysis

version_req: Option<VersionReq>

Version requirement for the source file. The source file may not declare the solidity version.

global_scope: VariableScopeRef

Global variable scope of the source file

steps: Vec<StepRef>

List of analyzed execution steps in this file

private_state_variables: Vec<VariableRef>

State variables that should be made public

contracts: Vec<ContractRef>

List of all contracts in this file.

functions: Vec<FunctionRef>

List of all functions in this file.

state_variables: Vec<VariableRef>

List of all state variables in this file.

private_functions: Vec<FunctionRef>

Functions that should be made public

immutable_functions: Vec<FunctionRef>

Functions that should be made mutable (i.e., neither pure nor view)

function_types: Vec<FunctionTypeNameRef>

Variables that are defined as function types

user_defined_types: Vec<UserDefinedTypeRef>

User defined types defined in this file.

Implementations

impl SourceAnalysis

pub fn variable_table(&self) -> HashMap<UVID, VariableRef>

Returns a mapping of all variables in this source file by their UVID.

This method traverses the entire variable scope tree and collects all variables into a flat HashMap for efficient lookup.

Returns

A HashMap mapping UVIDs to their corresponding VariableRef instances.

pub fn step_table(&self) -> HashMap<USID, StepRef>

Returns a mapping of all steps in this source file by their USID.

This method creates a HashMap for efficient step lookup by their unique step identifiers.

Returns

A HashMap mapping USIDs to their corresponding StepRef instances.

pub fn function_table(&self) -> HashMap<UFID, FunctionRef>

Returns a mapping of all functions in this source file by their UFID.

pub fn contract_table(&self) -> HashMap<UCID, ContractRef>

Returns a mapping of all contracts in this source file by their UCID.

pub fn user_defined_type_table(&self) -> HashMap<UTID, UserDefinedTypeRef>

Returns a mapping of all user defined types in this source file by their UTID.

pub fn user_defined_types(&self) -> HashMap<usize, UserDefinedTypeRef>

Returns a mapping of all user defined types in this source file by their AST ID.

Returns

A HashMap mapping AST IDs to their corresponding UserDefinedTypeRef instances.

pub fn pretty_display(&self, sources: &BTreeMap<u32, Source>)

Prints the analysis results in a human-readable format.

This method displays a comprehensive overview of the source analysis, including file information, variable scopes, execution steps, and recommendations for code improvements.

Example

use edb_engine::analysis::{Analyzer, SourceAnalysis};
use foundry_compilers::artifacts::Artifact;

// Assuming you have a compiled artifact
let artifact: Artifact = /* your compiled artifact */;

// Analyze the artifact
let analyses = Analyzer::analyze(&artifact).unwrap();

// Print the analysis results for each source file
for analysis in analyses {
    analysis.pretty_display();
}

This will output something like:

=== Source Analysis Report ===
File ID: 1
Path: contract.sol
Source Content Length: 1234 characters

=== Variable Scopes ===
Scope(SourceUnit): {}
  Scope(ContractDefinition): {balance, owner}
    Scope(Block): {amount}

=== Execution Steps (5 total) ===
Step 1 (USID: 0):
  Type: Variable Declaration
  Location: 45:12
  Source: uint256 balance = 0;
  Declared variables: balance (state): uint256 (Private)

Step 2 (USID: 1):
  Type: Expression
  Location: 50:15
  Source: transfer(amount);
  Function calls: transfer(1 args)

=== Recommendations ===
Private state variables that should be made public:
  - balance (visibility: Private)
=== End Report ===

Trait Implementations

impl Clone for SourceAnalysis

fn clone(&self) -> SourceAnalysis

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SourceAnalysis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SourceAnalysis

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SourceAnalysis

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.