Struct ContractIR 

pub struct ContractIR {

    pub name: String,
    pub kind: ContractKind,
    pub bases: Vec<Base>,
    pub functions: Vec<FunctionIR>,
    pub events: Vec<EventIR>,
    pub state_variables: Vec<StateVariableIR>,
    pub structs: Vec<StructIR>,
    pub enums: Vec<EnumIR>,
    pub doc: NatspecDocIR,
    pub has_using_for_star: bool,
    pub has_using_function_list: bool,
    pub using_for_libraries: Vec<String>,
    pub has_type_definitions: bool,
    pub type_aliases: HashMap<String, String>,
    pub super_method_map: HashMap<String, String>,
}

Representation of a Solidity contract.

Fields

name: String

kind: ContractKind

bases: Vec<Base>

Inheritance specifiers (contract X is A, B(...) { ... }).

functions: Vec<FunctionIR>

events: Vec<EventIR>

state_variables: Vec<StateVariableIR>

structs: Vec<StructIR>

enums: Vec<EnumIR>

doc: NatspecDocIR

Natspec documentation for this contract

has_using_for_star: bool

Whether this contract contains using X for Y directives.

The compiler merges library functions into the contract wholesale, so basic using LibName for Type works implicitly. This flag is set when advanced forms (using X for *, using { f, g } for Y) are present so that diagnostics can be emitted.

has_using_function_list: bool

using_for_libraries: Vec<String>

Library names referenced by using X for Y directives.

The compiler merges all non-builtin library functions into the contract wholesale, so using LibName for Type member-call syntax (e.g. x.add(y)) resolves to LibName.add(x, y) automatically. This list is kept for diagnostic purposes.

has_type_definitions: bool

Whether this contract contains type X is Y definitions.

type_aliases: HashMap<String, String>

User-defined value type aliases (type X is Y).

Maps the user-defined type name to its underlying Solidity type string. During type resolution, X is transparently replaced by Y. X.wrap(v) and X.unwrap(v) compile to no-ops.

super_method_map: HashMap<String, String>

Mapping from original method name to the renamed super-method name.

When inheritance flattening detects an override, the base version of the function is preserved as __super_{methodName} and this map records the relationship so that super.method() can be resolved during IR lowering.

Trait Implementations

impl Clone for ContractIR

fn clone(&self) -> ContractIR

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContractIR

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

Formats the value using the given formatter.