Enum ProgramPoint 

pub enum ProgramPoint {
    Invalid,
    Block {
        block: BlockRef,
        position: Position,
    },
    Op {
        op: OperationRef,
        position: Position,
    },
}

ProgramPoint represents a specific location in the execution of a program.

A program point consists of two parts:

• An anchor, either a block or operation
• A position, i.e. the direction relative to the anchor to which the program point refers

A program point can be reified as a cursor within a block, such that an operation inserted at the cursor will be placed at the specified position relative to the anchor.

Variants

Invalid

A program point which refers to nothing, and is always invalid if used

Block

A program point referring to the entry or exit of a block

Fields

block: BlockRef

The block this program point refers to

position: Position

The placement of the cursor relative to block

Op

A program point referring to the entry or exit of an operation

Fields

op: OperationRef

The operation this program point refers to

position: Position

The placement of the cursor relative to op

Implementations

impl ProgramPoint

pub fn before(entity: impl Into<ProgramPoint>) -> Self

Create a ProgramPoint at entry to entity, i.e. “before”

pub fn after(entity: impl Into<ProgramPoint>) -> Self

Create a ProgramPoint at exit from entity, i.e. “after”

pub fn at_start_of(block: impl Into<BlockPoint>) -> Self

Create a ProgramPoint at entry to block, i.e. “before”

pub fn at_end_of(block: impl Into<BlockPoint>) -> Self

Create a ProgramPoint at exit from block, i.e. “after”

pub fn is_at_block_start(&self) -> bool

Returns true if this program point is at the start of the containing block

pub fn is_at_block_end(&self) -> bool

Returns true if this program point is at the end of the containing block

pub fn block(&self) -> Option<BlockRef>

Returns the block of the program point anchor.

Returns None, if the program point is either invalid, or pointing to an orphaned operation

pub fn operation(&self) -> Option<OperationRef>

Returns the program point anchor as an operation.

Returns None if the program point is either invalid, or not pointing to a specific op

pub fn next_operation(&self) -> Option<OperationRef>

Returns the operation after Self::operation, relative to this program point.

If the current program point is in an orphaned operation, this will return the current op.

Returns None if the program point is either invalid, or not pointing to a specific op

pub fn prev_operation(&self) -> Option<OperationRef>

Returns the operation preceding Self::operation, relative to this program point.

If the current program point is in an orphaned operation, this will return the current op.

Returns None if the program point is either invalid, or not pointing to a specific op

pub fn is_valid(&self) -> bool

Returns true if this program point refers to a valid program point

pub fn is_unset(&self) -> bool

Returns true if this program point is invalid/unset

pub fn placement(&self) -> Position

The positioning relative to the program point anchor

pub fn cursor<'a, 'b: 'a, 'c: 'b>( &'c self, ) -> Option<EntityProjection<'b, EntityListCursor<'a, Operation>>>

Obtain an immutable cursor in the block corresponding to this program point.

The resulting cursor can have as_pointer or get called on it to get the operation to which this point is relative. The intuition around where the cursor is placed for a given program point can be understood as answering the question of “where does the cursor need to be, such that if I inserted an op at that cursor, that the insertion would be placed at the referenced program point (semantically before or after an operation or block). The specific rules are as follows:

• If “before” a block, the resulting cursor is the null cursor for the containing block, since an insertion at the null cursor will be placed at the start of the block.
• If “after” a block, the cursor is placed on the last operation in the block, as insertion will place the inserted op at the end of the block
• If “before” an operation, the cursor is placed on the operation immediately preceding self, or a null cursor is returned. In both cases, an insertion at the returned cursor would be placed immediately before self
• If “after” an operation, the cursor is placed on the operation in self, so that insertion will place the inserted op immediately after self.

NOTE: The block to which this program point refers will be borrowed for the lifetime of the returned EntityProjection.

pub fn cursor_mut<'a, 'b: 'a, 'c: 'b>( &'c mut self, ) -> Option<EntityProjectionMut<'b, EntityListCursorMut<'a, Operation>>>

Same as Self::cursor, but obtains a mutable cursor instead.

NOTE: The block to which this program point refers will be borrowed mutably for the lifetime of the returned EntityProjectionMut.

Trait Implementations

impl Clone for ProgramPoint

fn clone(&self) -> ProgramPoint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ProgramPoint

impl Debug for ProgramPoint

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

Formats the value using the given formatter.

impl Default for ProgramPoint

fn default() -> ProgramPoint

Returns the “default value” for a type.

impl Display for ProgramPoint

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

Formats the value using the given formatter.

impl Eq for ProgramPoint

impl From<&Block> for ProgramPoint

Construct a ProgramPoint referring to the point at entry to block

fn from(block: &Block) -> Self

Converts to this type from the input type.

impl From<&Operation> for ProgramPoint

Construct a ProgramPoint referring to the point at entry to op

fn from(op: &Operation) -> Self

Converts to this type from the input type.

impl<T> From<EntityMut<'_, T>> for ProgramPoint

where for<'a> ProgramPoint: From<&'a T>,

fn from(entity: EntityMut<'_, T>) -> Self

Converts to this type from the input type.

impl<T> From<EntityRef<'_, T>> for ProgramPoint

where for<'a> ProgramPoint: From<&'a T>,

fn from(entity: EntityRef<'_, T>) -> Self

Converts to this type from the input type.

impl From<RawEntityRef<Block, IntrusiveLink>> for ProgramPoint

Construct a ProgramPoint referring to the point at entry to block

fn from(block: BlockRef) -> Self

Converts to this type from the input type.

impl From<RawEntityRef<Operation, IntrusiveLink>> for ProgramPoint

Construct a ProgramPoint referring to the point at entry to op

fn from(op: OperationRef) -> Self

Converts to this type from the input type.

impl Hash for ProgramPoint

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ProgramPoint

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Spanned for ProgramPoint

fn span(&self) -> SourceSpan