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>
) -> Result<PartialPath, PathResolutionError>

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 is_complete_as_possible(&self, graph: &StackGraph) -> bool

A partial path is as complete as possible if we cannot extend it any further within the current file. This represents the maximal amount of work that we can pre-compute at index time.

pub fn is_productive(&self, partials: &mut PartialPaths) -> bool

Returns whether a partial path is “productive” — that is, whether it adds useful information to a path. Non-productive paths are ignored.

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 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(
    &mut self,
    graph: &StackGraph,
    partials: &mut PartialPaths
) -> Result<(), PathResolutionError>

Attempts to resolve any jump to scope node at the end of a partial path. 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 extend_from_file<R: Extend<PartialPath>>(
    &self,
    graph: &StackGraph,
    partials: &mut PartialPaths,
    file: Handle<File>,
    result: &mut R
)

Attempts to extend one partial path as part of the partial-path-finding algorithm, using only outgoing edges that belong to a particular file. When calling this function, you are responsible for ensuring that graph already contains data for all of the possible edges that we might want to extend path with.

The resulting extended partial paths will be added to result. We have you pass that in as a parameter, instead of building it up ourselves, so that you have control over which particular collection type to use, and so that you can reuse result collections across multiple calls.

impl PartialPath

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

Attempts to concatenate two partial paths. 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 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.