Struct dialectic_compiler::cfg::Cfg

pub struct Cfg { /* fields omitted */ }

A cfg of CFG nodes acting as a context for a single compilation unit.

Implementations

impl Cfg

pub fn new() -> Self

Construct an empty control flow graph.

pub fn insert(&mut self, node: CfgNode) -> Index

Insert a constructed CfgNode into the CFG, and get back its newly minted index.

pub fn insert_error_at(&mut self, node: Index, kind: CompileError)

Insert an Error node as a shim.

pub fn create_error(&mut self, kind: CompileError, span: Span) -> Index

Create a dummy Error node, as a stand-in for a node which should have been generated but for some reason cannot be.

pub fn singleton(&mut self, expr: Ir) -> Index

Create a new node containing only this expression with no next-node link.

pub fn spanned(&mut self, expr: Ir, span: Span) -> Index

Create a new node w/ an assigned span containing only this expression with no next-node link.

pub fn resolve_scopes(&mut self, node: Option<Index>)

The purpose of the scope resolution pass is to transform “implicit” continuations into “explicit” continuations. For example, consider the session type choose { ... }; send (). In this type, the first parsing of the block will result in a Choose node with its continuation/“next” pointer set to point to a Send(()) node. However, in order to ensure that the arms of the choose construct don’t have to worry about the continuation that comes “after” in a higher/parent scope, we have the resolve_scopes pass to “lower” this continuation which implicitly follows every arm of the Choose, into becoming the continuation of every relevant arm of the Choose. This does have some special cases, for example we don’t want to change or set a next continuation for a Break node or Continue node.

pub fn report_dead_code(&mut self, node: Option<Index>)

Attach errors to all dead code and code that leads to dead code, based on an internal call to the flow analysis and reachability analysis on the graph.

pub fn generate_target(
    &mut self,
    node: Option<Index>
) -> Result<Spanned<Target>, Error>

Traverse a Cfg rooted at the specified index to produce either a valid Target corresponding to it, or a syn::Error corresponding to one or more compiler errors.

Important: This function must be called after the scope resolution pass, or else the resultant code may omit sections of the input control flow graph due to implicit continuations which have not yet been resolved.

pub fn iter(&self) -> impl Iterator<Item = (Index, &CfgNode)> + '_

Iterate over all nodes in the CFG. The order is not defined.

Trait Implementations

impl Debug for Cfg

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

Formats the value using the given formatter.

impl Default for Cfg

fn default() -> Self

Returns the “default value” for a type.

impl Index<Index> for Cfg

type Output = CfgNode

The returned type after indexing.

fn index(&self, index: Index) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<Index> for Cfg

fn index_mut(&mut self, index: Index) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.