Struct Session

pub struct Session {
    pub dcx: DiagCtxt,
    pub evm_version: EvmVersion,
    pub language: Language,
    pub stop_after: Option<CompilerStage>,
    pub emit: BTreeSet<CompilerOutput>,
    pub out_dir: Option<PathBuf>,
    pub dump: Option<Dump>,
    pub pretty_json: bool,
    pub jobs: NonZeroUsize,
    /* private fields */
}

Information about the current compiler session.

Fields

dcx: DiagCtxt

The diagnostics context.

evm_version: EvmVersion

EVM version.

language: Language

Source code language.

stop_after: Option<CompilerStage>

Stop execution after the given compiler stage.

emit: BTreeSet<CompilerOutput>

Types of output to emit.

out_dir: Option<PathBuf>

Output directory.

dump: Option<Dump>

Internal state to dump to stdout.

pretty_json: bool

Pretty-print any JSON output.

jobs: NonZeroUsize

Number of threads to use. Already resolved to a non-zero value.

Implementations

impl Session

pub fn new(dcx: DiagCtxt, source_map: Arc<SourceMap>) -> Self

Creates a new session with the given diagnostics context and source map.

pub fn empty(dcx: DiagCtxt) -> Self

Creates a new session with the given diagnostics context and an empty source map.

pub fn builder() -> SessionBuilder

Creates a new session builder.

pub fn emitted_diagnostics(&self) -> Option<Result<(), EmittedDiagnostics>>

Returns Err with the printed diagnostics if any errors have been emitted.

Returns None if the underlying emitter is not a human buffer emitter created with with_buffer_emitter.

pub fn source_map(&self) -> &SourceMap

Returns a reference to the source map.

pub fn clone_source_map(&self) -> Arc<SourceMap>

Clones the source map.

pub fn stop_after(&self, stage: CompilerStage) -> bool

Returns true if compilation should stop after the given stage.

pub fn is_sequential(&self) -> bool

Returns true if parallelism is not enabled.

pub fn is_parallel(&self) -> bool

Returns true if parallelism is enabled.

pub fn do_emit(&self, output: CompilerOutput) -> bool

Returns true if the given output should be emitted.

pub fn spawn(&self, f: impl FnOnce() + Send + 'static)

Spawns the given closure on the thread pool or executes it immediately if parallelism is not enabled.

pub fn join<A, B, RA, RB>(&self, oper_a: A, oper_b: B) -> (RA, RB)

where A: FnOnce() -> RA + Send, B: FnOnce() -> RB + Send, RA: Send, RB: Send,

Takes two closures and potentially runs them in parallel. It returns a pair of the results from those closures.

pub fn scope<'scope, OP, R>(&self, op: OP) -> R

where OP: FnOnce(Scope<'_, 'scope>) -> R + Send, R: Send,

Executes the given closure in a fork-join scope.

See rayon::scope for more details.

pub fn enter<R>(&self, f: impl FnOnce() -> R) -> R

Sets up session globals on the current thread if they doesn’t exist already and then executes the given closure.

This also calls SessionGlobals::with_source_map.