Struct midenc_hir::pass::AnalysisManager

pub struct AnalysisManager { /* private fields */ }

The AnalysisManager is used to query and compute analyses required during compilation.

Each thread gets its own analysis manager, and may query any analysis, as long as the caller has the key used for caching that analysis (e.g. module identifier).

To compute an analysis, one must have a reference to the entity on which the analysis is applied, and request that the analysis be computed.

Analyses are cached, and assumed valid until explicitly invalidated. An analysis should be invalidated any time the underlying entity changes, unless the analysis is known to be preserved even with those changes.

Implementations

impl AnalysisManager

pub fn new() -> Self

Get a new, empty AnalysisManager.

pub fn is_available<A>( &self, key: &<<A as Analysis>::Entity as AnalysisKey>::Key, ) -> bool

where A: Analysis,

Check if the given analysis has been computed and is in the cache

pub fn get<A>( &self, key: &<<A as Analysis>::Entity as AnalysisKey>::Key, ) -> Option<Rc<A>>

where A: Analysis,

Get a reference to the analysis of the requested type, for the given entity, if available

pub fn expect<A>( &self, key: &<<A as Analysis>::Entity as AnalysisKey>::Key, msg: &str, ) -> Rc<A>

where A: Analysis,

Get a reference to the analysis of the requested type, for the given entity, or panics with msg

pub fn get_or_default<A>( &self, key: &<<A as Analysis>::Entity as AnalysisKey>::Key, ) -> Rc<A>

where A: Analysis + Default,

Get a reference to the analysis of the requested type, or the default value, for the given entity, if available

If unavailable, and the default value is returned, that value is not cached.

pub fn get_or_compute<A>( &mut self, entity: &<A as Analysis>::Entity, session: &Session, ) -> AnalysisResult<Rc<A>>

where A: Analysis,

Get a reference to the analysis of the requested type, computing it if necessary

If computing the analysis fails, Err is returned.

pub fn take<A>( &mut self, key: &<<A as Analysis>::Entity as AnalysisKey>::Key, ) -> Option<A>

where A: Analysis + Clone,

If an analysis of the requested type has been computed, take ownership of it, and return the owned object to the caller.

If there are outstanding references to the cached analysis data, then the data will be cloned so that the caller gets an owning reference.

If the analysis has not been computed, returns None

pub fn insert<A>( &mut self, key: <<A as Analysis>::Entity as AnalysisKey>::Key, analysis: A, )

where A: Analysis,

Insert an analysis into the manager with the given key

pub fn invalidate<T>(&mut self, key: &<T as AnalysisKey>::Key)

where T: AnalysisKey,

Mark all analyses as invalidated, unless otherwise preserved, forcing recomputation of those analyses the next time they are requested.

This clears any preservation markers that were set prior to calling this function, e.g. with mark_preserved. When this function returns, all analyses are assumed to be invalidated the next time this function is called, unless otherwise indicated.

pub fn mark_invalid<A>( &mut self, key: &<<A as Analysis>::Entity as AnalysisKey>::Key, )

where A: Analysis,

Mark the given analysis as no longer valid (due to changes to the analyzed entity)

You should invalidate analyses any time you modify the IR for that entity, unless you can guarantee that the specific analysis is preserved.

pub fn mark_none_preserved<T>(&mut self, key: &<T as AnalysisKey>::Key)

where T: AnalysisKey,

When called, the current pass is signalling that all analyses should be invalidated after it completes, regardless of any other configuration.

pub fn mark_all_preserved<T>(&mut self, key: &<T as AnalysisKey>::Key)

where T: AnalysisKey,

When called, the current pass is signalling that all analyses will still be valid after it completes, i.e. it makes no modifications that would invalidate an analysis.

Care must be taken when doing this, to ensure that the pass actually does not do anything that would invalidate any analysis results, or miscompiles are likely to occur.

pub fn mark_preserved<A>( &mut self, key: &<<A as Analysis>::Entity as AnalysisKey>::Key, )

where A: Analysis,

When called, the current pass is signalling that the given analysis identified by key, will still be valid after it completes.

This should only be called when the caller can guarantee that the analysis is truly preserved by the pass, otherwise miscompiles are likely to occur.

Trait Implementations

impl Default for AnalysisManager

fn default() -> AnalysisManager

Returns the “default value” for a type.