Struct Program 

pub struct Program {
    pub functions: HashMap<FunctionId, Function>,
    pub classes: HashMap<ClassId, Class>,
    pub modules: HashMap<ModuleId, Module>,
    pub global_statements: Vec<Statement>,
}

Program in the IR

Fields

functions: HashMap<FunctionId, Function>

Functions

classes: HashMap<ClassId, Class>

Classes

modules: HashMap<ModuleId, Module>

Modules

global_statements: Vec<Statement>

Global statements

Implementations

impl Program

pub fn new() -> Self

Create a new empty program

pub fn add_function(&mut self, function: Function)

Add a function to the program

pub fn add_class(&mut self, class: Class)

Add a class to the program

pub fn add_module(&mut self, module: Module)

Add a module to the program

pub fn add_global_statement(&mut self, statement: Statement)

Add a global statement

Trait Implementations

impl Clone for Program

fn clone(&self) -> Program

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Program

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Program

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Program

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Program

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Program