Struct Compiler 

pub struct Compiler<'a, 'l> {
    pub evm_version: &'l EVMVersion,
    pub sources: Arc<Vec<String>>,
    pub output: Option<String>,
    pub alternative_main: Option<String>,
    pub alternative_constructor: Option<String>,
    pub construct_args: Option<Vec<String>>,
    pub constant_overrides: Option<BTreeMap<&'a str, Bytes>>,
    pub bytecode: bool,
    pub cached: bool,
    pub file_provider: Arc<dyn FileProvider>,
    pub relax_jumps: bool,
    pub no_size_limit: bool,
}

The Core Huff Compiler

Usage

The canonical way to instantiate a Compiler instance is using the public associated new function.

Let’s say we want to create a Compiler for the ERC20.huff contract located in huff-examples.

We want our Compiler to output to an artifact:Vec<ethers_core::abi::token::Token>s directory, with no constructor arguments, and no verbose output:

use huff_neo_core::Compiler;
use huff_neo_utils::prelude::EVMVersion;
use std::sync::Arc;

let compiler = Compiler::new(
    &EVMVersion::default(),
    Arc::new(vec!["../../resources/erc20/ERC20.huff".to_string()]),
    Some("./artifacts".to_string()),
    None,
    None,
    None,
    None,
    false,
    false
);

Fields

evm_version: &'l EVMVersion

The EVM version to compile for

sources: Arc<Vec<String>>

The location of the files to compile

output: Option<String>

The output location

alternative_main: Option<String>

Macro to use a main

alternative_constructor: Option<String>

Constructor macro to use

construct_args: Option<Vec<String>>

Constructor Input Arguments

constant_overrides: Option<BTreeMap<&'a str, Bytes>>

Constant Overrides

bytecode: bool

Generate and log bytecode

cached: bool

Whether to check cached artifacts

file_provider: Arc<dyn FileProvider>

The implementation of a FileReader

relax_jumps: bool

Whether to apply jump relaxation optimization

no_size_limit: bool

Skip the contract and initcode size limit validation (EIP-170/EIP-3860, raised by EIP-7954 in Amsterdam)

Implementations

impl<'a, 'l> Compiler<'a, 'l>

pub fn new( evm_version: &'l EVMVersion, sources: Arc<Vec<String>>, output: Option<String>, alternative_main: Option<String>, alternative_constructor: Option<String>, construct_args: Option<Vec<String>>, constant_overrides: Option<BTreeMap<&'a str, Bytes>>, verbose: bool, cached: bool, ) -> Self

Public associated function to instantiate a new compiler.

pub fn new_in_memory( evm_version: &'l EVMVersion, sources: Arc<Vec<String>>, file_sources: HashMap<String, String>, alternative_main: Option<String>, alternative_constructor: Option<String>, construct_args: Option<Vec<String>>, constant_overrides: Option<BTreeMap<&'a str, Bytes>>, verbose: bool, ) -> Self

Creates a new instance of a compiler with an in-memory FileReader from the supplied sources map.

pub fn init_tracing_subscriber(directives: Option<Vec<Directive>>)

Tracing

Creates a new tracing subscriber to span the compilation process.

pub fn execute(&self) -> Result<Vec<Arc<Artifact>>, Arc<CompilerError>>

Executor

The core compilation process.

Steps

1. Transform inputs into File Paths with transform_paths.
2. Fetch file sources in parallel with fetch_sources.
3. Recurse file dependencies in parallel with recurse_deps.
4. For each top-level file generate the artifact using gen_artifact.
5. Return the compiling error(s) or successfully generated artifacts.

pub fn get_flattened_source( file: Arc<FileSource>, file_provider: Arc<dyn FileProvider>, ) -> Result<String, Arc<CompilerError>>

Get the flattened source code for a file with all dependencies resolved and #include statements commented out

pub fn grab_contracts(&self) -> Result<Vec<Contract>, Arc<CompilerError>>

Grab the ASTs for all file sources.

Steps

1. Transform inputs into File Paths with transform_paths.
2. Fetch file sources in parallel with fetch_sources.
3. Recurse file dependencies in parallel with recurse_deps.
4. For each top-level file, parse its contents and return a vec of [Contract] ASTs.

pub fn gen_artifact( &self, file: Arc<FileSource>, ) -> Result<Artifact, CompilerError>

Artifact Generation

Compiles a FileSource into an Artifact.

pub(crate) fn generate_artifact( &self, file: Arc<FileSource>, ) -> Result<(Artifact, HashSet<&'a str>), CompilerError>

Compiles a FileSource into an Artifact, together with the constant overrides its source mentions so they can be validated once all files are compiled.

pub fn fetch_sources( paths: Vec<PathBuf>, reader: Arc<dyn FileProvider>, ) -> Vec<Result<Arc<FileSource>, CompilerError>>

Get the file sources for a vec of PathBufs

pub fn recurse_deps( fs: Arc<FileSource>, remapper: &Remapper, reader: Arc<dyn FileProvider>, walk_level: HashSet<String>, ) -> Result<Arc<FileSource>, Arc<CompilerError>>

Recurses file dependencies

pub fn export_artifacts(artifacts: &Vec<Arc<Artifact>>, output: &OutputLocation)

Export Artifacts

Writes each artifact as JSON to the output file, or below the output directory at the path of its source file. Other files in the output directory are left alone.

pub(crate) fn constant_overrides_hex(&self) -> BTreeMap<String, String>

Returns the constant overrides as hex values by constant name.

pub(crate) fn found_constant_overrides( &self, tokens: &[Token], ) -> HashSet<&'a str>

Returns the constant overrides mentioned in a file’s tokens.

pub(crate) fn validate_constant_overrides( &self, found_overrides: &HashSet<&str>, ) -> Result<(), CompilerError>

Rejects constant overrides whose name appears in none of the compiled sources.

An override may set a constant the source references without defining it, and when several files are compiled it may target only some of them. So only a name that no source mentions is rejected: it cannot affect the output and is most likely a typo.

pub fn get_constructor_args(&self) -> Vec<String>

Derives Constructor Input Arguments

pub fn get_outputs(&self) -> OutputLocation

Derives an output location

Trait Implementations

impl<'a, 'l> Clone for Compiler<'a, 'l>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, 'l> Debug for Compiler<'a, 'l>

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

Formats the value using the given formatter.

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