Struct stack_graphs::partial::PartialPath

#[repr(C)]
pub struct PartialPath {
    pub start_node: Handle<Node>,
    pub end_node: Handle<Node>,
    pub symbol_stack_precondition: PartialSymbolStack,
    pub symbol_stack_postcondition: PartialSymbolStack,
    pub scope_stack_precondition: PartialScopeStack,
    pub scope_stack_postcondition: PartialScopeStack,
    pub edges: PartialPathEdgeList,
}

A portion of a name-binding path.

Partial paths can be computed incrementally, in which case all of the edges in the partial path belong to a single file. At query time, we can efficiently concatenate partial paths to yield a name-binding path.

Paths describe the contents of the symbol stack and scope stack at the end of the path. Partial paths, on the other hand, have preconditions and postconditions for each stack. The precondition describes what the stack must look like for us to be able to concatenate this partial path onto the end of a path. The postcondition describes what the resulting stack looks like after doing so.

The preconditions can contain scope stack variables, which describe parts of the scope stack (or parts of a scope symbol’s attached scope list) whose contents we don’t care about. The postconditions can also refer to those variables, and describe how those variable parts of the input scope stacks are carried through unmodified into the resulting scope stack.

Fields

start_node: Handle<Node>

end_node: Handle<Node>

symbol_stack_precondition: PartialSymbolStack

symbol_stack_postcondition: PartialSymbolStack

scope_stack_precondition: PartialScopeStack

scope_stack_postcondition: PartialScopeStack

edges: PartialPathEdgeList

Implementations

impl PartialPath

pub fn from_node( graph: &StackGraph, partials: &mut PartialPaths, node: Handle<Node> ) -> PartialPath

Creates a new empty partial path starting at a stack graph node.

pub fn shadows(&self, partials: &mut PartialPaths, other: &PartialPath) -> bool

Returns whether one path shadows another. Note that shadowing is not commutative — if path A shadows path B, the reverse is not true.

pub fn equals(&self, partials: &mut PartialPaths, other: &PartialPath) -> bool

pub fn cmp( &self, graph: &StackGraph, partials: &mut PartialPaths, other: &PartialPath ) -> Ordering

pub fn starts_at_reference(&self, graph: &StackGraph) -> bool

Returns whether a partial path represents the start of a name binding from a reference to a definition.

pub fn ends_at_definition(&self, graph: &StackGraph) -> bool

Returns whether a partial path represents the end of a name binding from a reference to a definition.

pub fn is_complete(&self, graph: &StackGraph) -> bool

A complete partial path represents a full name binding that resolves a reference to a definition.

pub fn starts_at_endpoint(&self, graph: &StackGraph) -> bool

pub fn ends_at_endpoint(&self, graph: &StackGraph) -> bool

pub fn ends_in_jump(&self, graph: &StackGraph) -> bool

pub fn is_cyclic( &self, graph: &StackGraph, partials: &mut PartialPaths ) -> Option<Cyclicity>

Returns whether a partial path is cyclic—that is, it starts and ends at the same node, and its postcondition is compatible with its precondition. If the path is cyclic, a tuple is returned indicating whether cycle requires strengthening the pre- or postcondition.

pub fn ensure_both_directions(&mut self, partials: &mut PartialPaths)

Ensures that the content of this partial path is available in both forwards and backwards directions.

pub fn ensure_forwards(&mut self, partials: &mut PartialPaths)

Ensures that the content of this partial path is in forwards direction.

pub fn largest_symbol_stack_variable(&self) -> u32

Returns the largest value of any symbol stack variable in this partial path.

pub fn largest_scope_stack_variable(&self, partials: &PartialPaths) -> u32

Returns the largest value of any scope stack variable in this partial path.

pub fn fresh_scope_stack_variable( &self, partials: &PartialPaths ) -> ScopeStackVariable

Returns a fresh scope stack variable that is not already used anywhere in this partial path.

pub fn display<'a>( &'a self, graph: &'a StackGraph, partials: &'a mut PartialPaths ) -> impl Display + 'a

impl PartialPath

pub fn ensure_no_overlapping_variables( &mut self, partials: &mut PartialPaths, other: &PartialPath )

Modifies this partial path so that it has no symbol or scope stack variables in common with another partial path.

pub fn eliminate_precondition_stack_variables( &mut self, partials: &mut PartialPaths )

Replaces stack variables in the precondition with empty stacks.

pub fn append( &mut self, graph: &StackGraph, partials: &mut PartialPaths, edge: Edge ) -> Result<(), PathResolutionError>

Attempts to append an edge to the end of a partial path. If the edge is not a valid extension of this partial path, we return an error describing why.

pub fn resolve_from_postcondition( &mut self, graph: &StackGraph, partials: &mut PartialPaths ) -> Result<(), PathResolutionError>

Attempts to resolve any jump to scope node at the end of a partial path from the postcondition scope stack. If the partial path does not end in a jump to scope node, we do nothing. If it does, and we cannot resolve it, then we return an error describing why.

pub fn resolve_to_node( &mut self, graph: &StackGraph, partials: &mut PartialPaths, node: Handle<Node> ) -> Result<(), PathResolutionError>

Resolve any jump to scope node at the end of a partial path to the given node, updating the precondition to include the given node. If the partial path does not end in a jump to scope node, we do nothing. If it does, and we cannot resolve it, then we return an error describing why.

impl PartialPath

pub fn concatenate( &mut self, graph: &StackGraph, partials: &mut PartialPaths, rhs: &PartialPath ) -> Result<(), PathResolutionError>

Attempts to append a partial path to this one. If the postcondition of the “left” partial path is not compatible with the precondition of the “right” path, we return an error describing why.

If the left- and right-hand partial paths have any symbol or scope stack variables in common, then we ensure that the variables bind to the same values on both sides. It’s your responsibility to update the two partial paths so that they have no variables in common, if that’s needed for your use case.

Trait Implementations

impl Appendable for PartialPath

fn append_to( &self, graph: &StackGraph, partials: &mut PartialPaths, path: &mut PartialPath ) -> Result<(), PathResolutionError>

Append this appendable to the given path. Resolving jump nodes and renaming unused_variables is part of the responsibility of this method.

fn start_node(&self) -> Handle<Node>

Return the start node.

fn end_node(&self) -> Handle<Node>

Return the end node.

fn display<'a>( &'a self, graph: &'a StackGraph, partials: &'a mut PartialPaths ) -> Box<dyn Display + 'a>

Return a Display implementation.

impl Clone for PartialPath

fn clone(&self) -> PartialPath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<PartialPath> for sg_partial_path

fn into(self) -> PartialPath

Converts this type into the (usually inferred) input type.

impl ToAppendable<Handle<PartialPath>, PartialPath> for Database

fn get_appendable<'a>( &'a self, handle: &'a Handle<PartialPath> ) -> &'a PartialPath