Struct Session 

pub struct Session {
    pub opts: Opts,
    pub dcx: DiagCtxt,
    /* private fields */
}

Information about the current compiler session.

Fields

opts: Opts

The compiler options.

dcx: DiagCtxt

The diagnostics context.

Implementations

impl Session

pub fn builder() -> SessionBuilder

Creates a new session builder.

pub fn new(opts: Opts) -> Self

Creates a new session from the given options.

See builder for a more flexible way to create a session.

pub fn infer_language(&mut self)

Infers the language from the input files.

pub fn validate(&self) -> Result<()>

Validates the session options.

pub fn reconfigure(&self)

Reconfigures inner state to match any new options.

Call this after updating options.

pub fn unstable(&self) -> &UnstableOpts

Returns the unstable options.

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

Returns the emitted diagnostics as a result. Can be empty.

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

Results Ok if there are no errors, Err otherwise.

Examples

Print diagnostics to stdout if there are no errors, otherwise propagate with ?:

println!("{}", dcx.emitted_diagnostics_result().unwrap()?);

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

Returns the emitted diagnostics. Can be empty.

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

pub fn emitted_errors(&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 threads(&self) -> usize

Returns the number of threads to use for parallelism.

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.

NOTE: on a use_current_thread thread pool rayon::spawn will never execute without yielding to rayon, so prefer using this method over rayon::spawn.

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.

NOTE: on a use_current_thread thread pool rayon::join will never execute without yielding to rayon, so prefer using this method over rayon::join.

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: Send>(&self, f: impl FnOnce() -> R + Send) -> R

Sets up the session globals and executes the given closure in the thread pool.

The thread pool and globals are stored in this Session itself, meaning multiple consecutive calls to enter will share the same globals and resources.

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

Sets up the session globals and executes the given closure in the current thread.

Note that this does not set up the rayon thread pool. This is only useful when parsing sequentially, like manually using Parser. Otherwise, it might cause panics later on if a thread pool is expected to be set up correctly.

See enter for more details.

Trait Implementations

impl Default for Session

fn default() -> Self

Returns the “default value” for a type.

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