Struct leo_compiler::Compiler

pub struct Compiler<'a, N: Network> {
    handler: &'a Handler,
    main_file_path: PathBuf,
    output_directory: PathBuf,
    pub program_name: String,
    pub network: String,
    pub ast: Ast,
    compiler_options: CompilerOptions,
    node_builder: NodeBuilder,
    assigner: Assigner,
    type_table: TypeTable,
    import_stubs: IndexMap<Symbol, Stub>,
    phantom: PhantomData<N>,
}

The primary entry point of the Leo compiler.

Fields

handler: &'a Handler

The handler is used for error and warning emissions.

main_file_path: PathBuf

The path to the main leo file.

output_directory: PathBuf

The path to where the compiler outputs all generated files.

program_name: String

The program name,

network: String

The network name,

ast: Ast

The AST for the program.

compiler_options: CompilerOptions

Options configuring compilation.

node_builder: NodeBuilder

The NodeCounter used to generate sequentially increasing NodeIDs.

assigner: Assigner

The Assigner is used to construct (unique) assignment statements.

type_table: TypeTable

The type table.

import_stubs: IndexMap<Symbol, Stub>

The stubs for imported programs. Produced by Retriever module.

phantom: PhantomData<N>

Implementations

impl<'a, N: Network> Compiler<'a, N>

pub fn new( program_name: String, network: String, handler: &'a Handler, main_file_path: PathBuf, output_directory: PathBuf, compiler_options: Option<CompilerOptions>, import_stubs: IndexMap<Symbol, Stub> ) -> Self

Returns a new Leo compiler.

pub fn checksum(&self) -> Result<String>

Returns a SHA256 checksum of the program file.

pub fn parse_program_from_string( &mut self, program_string: &str, name: FileName ) -> Result<()>

Parses and stores a program file content from a string, constructs a syntax tree, and generates a program.

pub fn parse_program(&mut self) -> Result<()>

Parses and stores the main program file, constructs a syntax tree, and generates a program.

pub fn symbol_table_pass(&self) -> Result<SymbolTable>

Runs the symbol table pass.

pub fn type_checker_pass( &'a self, symbol_table: SymbolTable ) -> Result<(SymbolTable, StructGraph, CallGraph)>

Runs the type checker pass.

pub fn loop_unrolling_pass( &mut self, symbol_table: SymbolTable ) -> Result<SymbolTable>

Runs the loop unrolling pass.

pub fn static_single_assignment_pass( &mut self, symbol_table: &SymbolTable ) -> Result<()>

Runs the static single assignment pass.

pub fn flattening_pass(&mut self, symbol_table: &SymbolTable) -> Result<()>

Runs the flattening pass.

pub fn destructuring_pass(&mut self) -> Result<()>

Runs the destructuring pass.

pub fn function_inlining_pass(&mut self, call_graph: &CallGraph) -> Result<()>

Runs the function inlining pass.

pub fn dead_code_elimination_pass(&mut self) -> Result<()>

Runs the dead code elimination pass.

pub fn code_generation_pass( &mut self, symbol_table: &SymbolTable, struct_graph: &StructGraph, call_graph: &CallGraph ) -> Result<String>

Runs the code generation pass.

pub fn compiler_stages( &mut self ) -> Result<(SymbolTable, StructGraph, CallGraph)>

Runs the compiler stages.

pub fn compile(&mut self) -> Result<String>

Returns a compiled Leo program.

fn write_ast_to_json(&self, file_suffix: &str) -> Result<()>

Writes the AST to a JSON file.

fn write_symbol_table_to_json( &self, file_suffix: &str, symbol_table: &SymbolTable ) -> Result<()>

Writes the Symbol Table to a JSON file.

pub fn add_import_stubs(&mut self) -> Result<()>

Merges the dependencies defined in program.json with the dependencies imported in .leo file

Trait Implementations

impl<'a, N: Clone + Network> Clone for Compiler<'a, N>

fn clone(&self) -> Compiler<'a, N>

Returns a copy of the value.

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

Performs copy-assignment from source.