Struct Compiler

pub struct Compiler {

    pub target_dir: PathBuf,
    pub working_dir: Option<PathBuf>,
    pub sysroot: Option<PathBuf>,
    pub output_dir: Option<PathBuf>,
    pub output_file: Option<PathBuf>,
    pub stdout: bool,
    pub name: Option<String>,
    pub verbosity: Verbosity,
    pub warn: Warnings,
    pub color: ColorChoice,
    pub target: TargetEnv,
    pub entrypoint: Option<String>,
    pub is_program: bool,
    pub is_library: bool,
    pub search_path: Vec<PathBuf>,
    pub link_libraries: Vec<LinkLibrary>,
    pub output_types: Vec<OutputTypeSpec>,
    pub debug: DebugInfo,
    pub opt_level: OptLevel,
    pub codegen: Vec<String>,
    pub unstable: Vec<String>,
}

Compile a program from WebAssembly or Miden IR, to Miden Assembly.

Fields

target_dir: PathBuf

Write all intermediate compiler artifacts to <dir>

Defaults to a directory named target/midenc in the current working directory

working_dir: Option<PathBuf>

The working directory for the compiler

By default this will be the working directory the compiler is executed from

sysroot: Option<PathBuf>

The path to the root directory of the Miden toolchain libraries

By default this is assumed to be ~/.miden/toolchains/

output_dir: Option<PathBuf>

Write compiled output to compiler-chosen filename in <dir>

output_file: Option<PathBuf>

Write compiled output to <filename>

stdout: bool

Write output to stdout

name: Option<String>

Specify the name of the project being compiled

The default is derived from the name of the first input file, or if reading from stdin, the base name of the working directory.

verbosity: Verbosity

Specify what type and level of informational output to emit

warn: Warnings

Specify how warnings should be treated by the compiler.

color: ColorChoice

Whether, and how, to color terminal output

target: TargetEnv

The target environment to compile for

entrypoint: Option<String>

Specify the function to call as the entrypoint for the program

is_program: bool

Tells the compiler to produce an executable Miden program

Implied by --entrypoint, defaults to true for non-rollup targets.

is_library: bool

Tells the compiler to produce a Miden library

Implied by --target rollup, defaults to false.

search_path: Vec<PathBuf>

Specify one or more search paths for link libraries requested via -l

link_libraries: Vec<LinkLibrary>

Link compiled projects to the specified library NAME.

The optional KIND can be provided to indicate what type of library it is.

NAME must either be an absolute path (with extension when applicable), or a library namespace (no extension). The former will be used as the path to load the library, without looking for it in the library search paths, while the latter will be located in the search path based on its KIND.

See below for valid KINDs:

output_types: Vec<OutputTypeSpec>

Specify one or more output types for the compiler to emit

The format for SPEC is KIND[=PATH]. You can specify multiple items at once by separating each SPEC with a comma, you can also pass this flag multiple times.

PATH must be a directory in which to place the outputs, or - for stdout.

debug: DebugInfo

Specify what level of debug information to emit in compilation artifacts

opt_level: OptLevel

Specify what type, and to what degree, of optimizations to apply to code during compilation.

codegen: Vec<String>

Set a codegen option

Use -C help to print available options

unstable: Vec<String>

Set an unstable compiler option

Use -Z help to print available options

Implementations

impl Compiler

pub fn new_session<I, A, S>( inputs: I, emitter: Option<Arc<dyn Emitter>>, argv: A, ) -> Session

where I: IntoIterator<Item = InputFile>, A: IntoIterator<Item = S>, S: Into<OsString> + Clone,

Construct a Compiler programatically

pub fn into_session( self, inputs: Vec<InputFile>, emitter: Option<Arc<dyn Emitter>>, ) -> Session

Use this configuration to obtain a Session used for compilation

Trait Implementations

impl Args for Compiler

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl CommandFactory for Compiler

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Compiler

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

Formats the value using the given formatter.

impl FromArgMatches for Compiler

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Compiler

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.