Struct SessionSource

pub struct SessionSource {
    pub file_name: PathBuf,
    pub contract_name: String,
    pub solc: Solc,
    pub global_code: String,
    pub top_level_code: String,
    pub run_code: String,
    pub generated_output: Option<GeneratedOutput>,
    pub config: SessionSourceConfig,
}

REPL Session Source wrapper

Heavily based on soli’s ConstructedSource

Fields

file_name: PathBuf

The file name

contract_name: String

The contract name

solc: Solc

The solidity compiler version

global_code: String

Global level solidity code

Typically, global-level code is present between the contract definition and the first function (usually constructor)

top_level_code: String

Top level solidity code

Typically, this is code seen above the constructor

run_code: String

Code existing within the “run()” function’s scope

generated_output: Option<GeneratedOutput>

The generated output

config: SessionSourceConfig

Session Source configuration

Implementations

impl SessionSource

pub fn new(solc: Solc, config: SessionSourceConfig) -> Self

Creates a new source given a solidity compiler version

Panics

If no Solc binary is set, cannot be found or the --version command fails

Takes

• An instance of [Solc]
• An instance of SessionSourceConfig

Returns

A new instance of SessionSource

pub fn shallow_clone(&self) -> Self

Clones a SessionSource without copying the GeneratedOutput, as it will need to be regenerated as soon as new code is added.

Returns

A shallow-cloned SessionSource

pub fn clone_with_new_line(&self, content: String) -> Result<(Self, bool)>

Clones the SessionSource and appends a new line of code. Will return an error result if the new line fails to be parsed.

Returns

Optionally, a shallow-cloned SessionSource with the passed content appended to the source code.

pub fn with_global_code(&mut self, content: &str) -> &mut Self

Appends global-level code to the source

pub fn with_top_level_code(&mut self, content: &str) -> &mut Self

Appends top-level code to the source

pub fn with_run_code(&mut self, content: &str) -> &mut Self

Appends code to the “run()” function

pub fn drain_global_code(&mut self) -> &mut Self

Clears global code from the source

pub fn drain_top_level_code(&mut self) -> &mut Self

Clears top-level code from the source

pub fn drain_run(&mut self) -> &mut Self

Clears the “run()” function’s code

pub fn compiler_input(&self) -> SolcInput

Generates and [SolcInput] from the source.

Returns

A [SolcInput] object containing forge-std’s Vm interface as well as the REPL contract source.

pub fn parse(&self) -> Result<SourceUnit, Vec<Diagnostic>>

Compiles the source using [solang_parser]

Returns

A [pt::SourceUnit] if successful. A vec of [solang_parser::diagnostics::Diagnostic]s if unsuccessful.

pub fn generate_intermediate_contracts( &self, ) -> Result<HashMap<String, IntermediateContract>>

Generate intermediate contracts for all contract definitions in the compilation source.

Returns

Optionally, a map of contract names to a vec of IntermediateContracts.

pub fn generate_intermediate_output(&self) -> Result<IntermediateOutput>

Generate intermediate output for the REPL contract

pub fn compile(&self) -> Result<CompilerOutput>

Compile the contract

Returns

Optionally, a [CompilerOutput] object that contains compilation artifacts.

pub fn build(&mut self) -> Result<GeneratedOutput>

Builds the SessionSource from input into the complete CompiledOutput

Returns

Optionally, a GeneratedOutput object containing both the [CompilerOutput] and the IntermediateOutput.

pub fn to_script_source(&self) -> String

Convert the SessionSource to a valid Script contract

Returns

The SessionSource represented as a Forge Script contract.

pub fn to_repl_source(&self) -> String

Convert the SessionSource to a valid REPL contract

Returns

The SessionSource represented as a REPL contract.

pub fn get_intermediate_contract( content: &str, res_map: &mut HashMap<String, IntermediateContract>, )

Gets the IntermediateContract for a Solidity source string and inserts it into the passed res_map. In addition, recurses on any imported files as well.

Takes

• content - A Solidity source string
• res_map - A mutable reference to a map of contract names to IntermediateContracts

pub fn get_statement_definitions( statement: &Statement, ) -> Vec<(String, Expression)>

Helper to deconstruct a statement

Takes

A reference to a [pt::Statement]

Returns

A vector containing tuples of the inner expressions’ names, types, and storage locations.

impl SessionSource

Executor implementation for SessionSource

pub async fn execute(&mut self) -> Result<(Address, ChiselResult)>

Runs the source with the ChiselRunner

Returns

Optionally, a tuple containing the [Address] of the deployed REPL contract as well as the ChiselResult.

Returns an error if compilation fails.

pub async fn inspect(&self, input: &str) -> Result<(bool, Option<String>)>

Inspect a contract element inside of the current session

Takes

A solidity snippet

Returns

If the input is valid Ok((continue, formatted_output)) where:

• continue is true if the input should be appended to the source
• formatted_output is the formatted value, if any

fn infer_inner_expr_type(&self) -> Option<&Expression>

Gracefully attempts to extract the type of the expression within the abi.encode(...) call inserted by the inspect function.

Takes

A reference to a SessionSource

Returns

Optionally, a Type

async fn prepare_runner(&mut self, final_pc: usize) -> ChiselRunner

Prepare a runner for the Chisel REPL environment

Takes

The final statement’s program counter for the ChiselInspector

Returns

A configured ChiselRunner

Trait Implementations

impl Clone for SessionSource

fn clone(&self) -> SessionSource

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SessionSource

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SessionSource

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SessionSource

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

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