Struct Context 

pub struct Context { /* private fields */ }

Represents the shared state of the IR, used during a compilation session.

The primary purpose(s) of the context are:

• Provide storage/memory for all allocated IR entities for the lifetime of the session.
• Provide unique value and block identifiers for printing the IR
• Provide a uniqued constant pool
• Provide configuration used during compilation

Safety

The Context must live as long as any reference to an IR entity may be dereferenced.

Implementations

impl Context

pub fn new(session: Rc<Session>) -> Self

Create a new Context for the given Session

pub fn session(&self) -> &Session

pub fn session_rc(&self) -> Rc<Session>

pub fn diagnostics(&self) -> &DiagnosticsHandler

pub fn registered_dialects(&self) -> Ref<'_, FxHashMap<Symbol, Rc<dyn Dialect>>>

pub fn get_registered_dialect( &self, dialect: impl Into<Symbol>, ) -> Rc<dyn Dialect>

pub fn get_or_register_dialect<T>(&self) -> Rc<dyn Dialect>

where T: DialectRegistration,

pub fn register_dialect_hook<T, F>(&self, hook: F)

where T: DialectRegistration, F: Fn(&mut DialectInfo, &Context) + 'static,

pub fn create_constant(&self, data: impl Into<ConstantData>) -> ConstantId

pub fn get_constant(&self, id: ConstantId) -> Arc<ConstantData>

pub fn get_constant_size_in_bytes(&self, id: ConstantId) -> usize

pub fn get_cached_type<T: BuildableTypeConstraint>(&self) -> Option<Arc<Type>>

pub fn get_or_insert_type<T: BuildableTypeConstraint>(&self) -> Arc<Type>

pub fn builder(self: Rc<Self>) -> OpBuilder

Get a new OpBuilder for this context

pub fn create_block(&self) -> BlockRef

Create a new, detached and empty Block with no parameters

pub fn create_block_with_params<I>(&self, tys: I) -> BlockRef

where I: IntoIterator<Item = Type>,

Create a new, detached and empty Block, with parameters corresponding to the given types

pub fn append_block_argument( &self, block: BlockRef, ty: Type, span: SourceSpan, ) -> ValueRef

Append a new BlockArgument to block, with the given type and source location

Returns the block argument as a dyn Value reference

pub fn make_operand( &self, value: ValueRef, owner: OperationRef, index: u8, ) -> OpOperand

Create a new OpOperand with the given value, owner, and index.

NOTE: This inserts the operand as a user of value, but does not add the operand to owner’s operand storage, the caller is expected to do that. This makes this function a more useful primitive.

pub fn make_block_operand( &self, block: BlockRef, owner: OperationRef, index: u8, ) -> BlockOperandRef

Create a new BlockOperand with the given block, owner, and index.

NOTE: This inserts the block operand as a user of block, but does not add the block operand to owner’s successor storage, the caller is expected to do that. This makes this function a more useful primitive.

pub fn make_result( &self, span: SourceSpan, ty: Type, owner: OperationRef, index: u8, ) -> OpResultRef

Create a new OpResult with the given type, owner, and index

NOTE: This does not attach the result to the operation, it is expected that the caller will do so.

pub fn append_branch_destination_argument( &self, branch_inst: OperationRef, dest: BlockRef, value: ValueRef, )

Appends value as an argument to the branch_inst instruction arguments list if the destination block of the branch_inst is dest.

NOTE: Panics if branch_inst is not a branch instruction.

pub fn alloc_uninit<T: 'static>(&self) -> UnsafeEntityRef<MaybeUninit<T>>

Allocate a new uninitialized entity of type T

In general, you can probably prefer Context::alloc instead, but for use cases where you need to allocate the space for T first, and then perform initialization, this can be used.

pub fn alloc_uninit_tracked<T: 'static>( &self, ) -> UnsafeIntrusiveEntityRef<MaybeUninit<T>>

Allocate a new uninitialized entity of type T, which needs to be tracked in an intrusive doubly-linked list.

In general, you can probably prefer Context::alloc_tracked instead, but for use cases where you need to allocate the space for T first, and then perform initialization, this can be used.

pub fn alloc<T: 'static>(&self, value: T) -> UnsafeEntityRef<T>

Allocate a new EntityHandle<T>.

[EntityHandle] is a smart-pointer type for IR entities, which behaves like a ref-counted pointer with dynamically-checked borrow checking rules. It is designed to play well with entities allocated from a Context, and with the somewhat cyclical nature of the IR.

pub fn alloc_tracked<T: 'static>(&self, value: T) -> UnsafeIntrusiveEntityRef<T>

Allocate a new TrackedEntityHandle<T>.

[TrackedEntityHandle] is like [EntityHandle], except that it is specially designed for entities which are meant to be tracked in intrusive linked lists. For example, the blocks in a region, or the ops in a block. It does this without requiring the entity to know about the link at all, while still making it possible to access the link from the entity.

Trait Implementations

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.