Struct Session 

pub struct Session {
    pub name: String,
    pub options: Box<Options>,
    pub source_manager: Arc<dyn SourceManager>,
    pub diagnostics: Arc<DiagnosticsHandler>,
    pub input: Option<InputFile>,
    pub output_files: OutputFiles,
    pub statistics: Statistics,
    /* private fields */
}

This struct provides access to all of the metadata and configuration needed during a single compilation session.

Fields

name: String

The name of this session

options: Box<Options>

Configuration for the current compiler session

source_manager: Arc<dyn SourceManager>

The current source manager

diagnostics: Arc<DiagnosticsHandler>

The current diagnostics handler

input: Option<InputFile>

The inputs being compiled

output_files: OutputFiles

The outputs to be produced by the compiler during compilation

statistics: Statistics

Statistics gathered from the current compiler session

Implementations

impl Session

pub fn new( input: InputFile, options: Box<Options>, emitter: Option<Arc<dyn Emitter>>, source_manager: Arc<dyn SourceManager + Send + Sync>, ) -> Result<Self, Report>

Open a session compiling input under options.

A project locator is read for its facts, not loaded as a project

A .toml input is a locator: it names the project to build rather than being something the compiler compiles. Three facts about that project are needed before this session exists, because this constructor is downstream of none of them:

• the package name, which is the artifact name absent --name, and which OutputFiles is built from below;
• the library target’s kind, which is what Options::target_type defaults to, and which add_target_link_libraries then consults to decide whether the Miden protocol is linked;
• the executable targets’ names, from which Options::entrypoint is defaulted.

All three come from ProjectManifest, which parses the manifest’s AST and reads exactly those three things out of it with miden_project’s own extractors. What it deliberately does not do is build a miden_project::Project: loading the project is prepare_project’s, in midenc-compile, and the package it loads is the one that gets assembled. A session that loaded its own would be loading the same manifest twice to produce a package nothing compiles.

Failing to read the manifest is not an error here. Which project a locator names, and whether it names one at all, is decided and reported downstream — where the locator is normalized anyway, and where a Cargo workspace root gets the diagnostic that belongs to it rather than a “no such file” for the miden-project.toml a workspace root does not have. So an unreadable manifest falls back to the same name derivation a source-file input uses, and leaves target_type and entrypoint alone.

pub fn new_project( name: String, input: Option<InputFile>, options: Box<Options>, emitter: Option<Arc<dyn Emitter>>, source_manager: Arc<dyn SourceManager>, ) -> Self

Open a session named name, for a caller that already knows what it is building.

Session::new derives name from its input; this takes it. Both then do the same thing, and neither knows anything about the project being built beyond its name.

pub fn get_flag(&self, name: &str) -> bool

Get the value of a custom flag with action FlagAction::SetTrue or FlagAction::SetFalse

pub fn get_flag_count(&self, name: &str) -> usize

Get the count of a specific custom flag with action FlagAction::Count

pub fn matches(&self) -> &ArgMatches

Get the remaining ArgMatches left after parsing the base session configuration

pub fn name(&self) -> &str

The name of this session (used as the name of the project, output file, etc.)

pub fn package_registry(&self) -> Result<Box<HybridPackageRegistry>, Report>

Get a new package registry instance for this session

pub fn filesystem_package_cache_dir(&self) -> Result<Option<PathBuf>, Report>

Where compiled dependency packages of this build are published and looked for.

Ok(None) unless this session’s input is a project locator: a session compiling a standalone source file has no project to exchange packages for. When the calling process already exported MIDENC_PACKAGE_CACHE, that directory is adopted as-is and left in place — the caller owns its location and lifetime (this is how a contract build.rs keeps the packages readable after the compiler exits). Otherwise the directory is a per-build lease with a globally unique name under the session’s configured target directory (<target-dir>/packages), created on first access and deleted when the last clone of this session drops; see the package_lease module for both lifecycles. Anchoring at the target directory honors a caller-supplied --target-dir — a writable location for a read-only checkout, for example.

Both readers — this session’s package registry and the nested cargo builds a Rust project’s dependencies run through — must agree on the answer, which is why there is one derivation of it. Only the root compilation session derives the path. Nested dependency sessions receive the root value threaded through their build environment, rather than deriving paths from their own locators: a dependency with a private directory could not see its already-assembled transitive dependencies.

Session is Clone, and clones share the lease cell, so every clone observes the same directory and no clone can mint a second one. Errors when the directory cannot be created — fail closed, so the build stops here instead of failing later inside a macro expansion with a confusing missing-package diagnostic; the failure is memoized and re-reported on every access.

Derived from the input locator rather than from a loaded manifest, which is what Session::new no longer has. That is also a repair: the manifest path was previously taken from a package that fixup_cargo_target had rebuilt for every executable Cargo.toml input, and a rebuilt package has no manifest path — so an executable project silently got no filesystem cache at all, while a library project of the same shape got one.

pub fn out_file(&self) -> OutputFile

Get the OutputFile to write the assembled MAST output to

pub fn parse_only(&self) -> bool

Returns true if the compiler should exit after parsing the input

pub fn analyze_only(&self) -> bool

Returns true if the compiler should exit after performing semantic analysis

pub fn rewrite_only(&self) -> bool

Returns true if the compiler should exit after applying rewrites to the IR

pub fn should_link(&self) -> bool

Returns true if an OutputType that requires linking + assembly was requested

pub fn should_codegen(&self) -> bool

Returns true if an OutputType that requires generating Miden Assembly was requested

pub fn should_assemble(&self) -> bool

Returns true if an OutputType that requires assembling MAST was requested

pub fn should_emit(&self, ty: OutputType) -> bool

Returns true if the given OutputType should be emitted as an output

pub fn should_print_ir(&self, pass: &str) -> bool

Returns true if IR should be printed to stdout, after executing a pass named pass

pub fn should_print_ir_before_stage(&self, stage: &str) -> bool

Returns true if IR should be printed to stdout, at the start of stage

pub fn should_print_cfg(&self, pass: &str) -> bool

Returns true if CFG should be printed to stdout, after executing a pass named pass

pub fn print(&self, ir: impl Emit, pass: &str) -> Result<()>

Print the given emittable IR to stdout, as produced by a pass with name pass

pub fn emit_to(&self, ty: OutputType, name: Option<Symbol>) -> Option<PathBuf>

Get the path to emit the given OutputType to

pub fn emit<E: Emit>(&self, mode: OutputMode, item: &E) -> Result<()>

Emit an item to stdout/file system depending on the current configuration

pub fn output_path_for( &self, output_type: OutputType, name: Option<&str>, ) -> Option<OutputFile>

Given an OutputType and an optional name, return the output file path that would be written to.

Returns Some if the specified output type should be emitted, and None if it should not.

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Session

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

Formats the value using the given formatter.