Struct paralegal_policy::GlobalNode

pub struct GlobalNode {
    pub(crate) node: NodeIndex<u32>,
    pub(crate) controller_id: DefId,
}

A globally identified node in an SPDG

Fields

node: NodeIndex<u32>

controller_id: DefId

Implementations

impl GlobalNode

pub fn unsafe_new(ctrl_id: DefId, index: usize) -> GlobalNode

Create a new node with no guarantee that it exists in the SPDG of the controller.

pub fn from_local_node(ctrl_id: DefId, node: NodeIndex<u32>) -> GlobalNode

Create a new globally identified node by pairing a node local to a particular SPDG with it’s controller id.

Meant for internal use only.

pub fn local_node(self) -> NodeIndex<u32>

The local node in the SPDG

pub fn controller_id(self) -> DefId

The identifier for the SPDG this node is contained in

Trait Implementations

impl Clone for GlobalNode

fn clone(&self) -> GlobalNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GlobalNode

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

Formats the value using the given formatter.

impl Hash for GlobalNode

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

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 IntoIterGlobalNodes for GlobalNode

type Iter = Once<NodeIndex<u32>>

The iterator returned by Self::iter_nodes

fn iter_nodes(self) -> <GlobalNode as IntoIterGlobalNodes>::Iter

iterate over the local nodes

fn controller_id(self) -> DefId

The controller id all of these nodes are located in.

fn iter_global_nodes(self) -> GlobalNodeIter<Self>

Iterate all nodes as globally identified one’s.

fn extended(self, other: impl IntoIterGlobalNodes) -> Option<NodeCluster>

A convenience method for gathering multiple node(cluster)s together.

fn to_local_cluster(self) -> NodeCluster

Collect the iterator into a cluster

impl NodeExt for GlobalNode

fn has_marker<C: HasDiagnosticsBase>(self, ctx: C, marker: Marker) -> bool

Returns whether this Node has the marker applied to it directly or via its type.

fn has_type(self, t: TypeId, ctx: &Context) -> bool

Returns true if this node has the provided type

fn associated_call_site(self, ctx: &Context) -> CallString

Find the call string for the statement or function that produced this node.

fn types(self, ctx: &Context) -> &[TypeId]

Get the type(s) of a Node.

fn describe(self, ctx: &Context) -> DisplayNode<'_>

Returns a DisplayNode for the given Node

fn info(self, ctx: &Context) -> &NodeInfo

Retrieve metadata about a node.

fn instruction(self, ctx: &Context) -> &InstructionInfo

Retrieve metadata about the instruction executed by a specific node.

fn successors(self, ctx: &Context) -> Box<dyn Iterator<Item = GlobalNode> + '_>

Return the immediate successors of this node

fn predecessors( self, ctx: &Context ) -> Box<dyn Iterator<Item = GlobalNode> + '_>

Return the immediate predecessors of this node

fn get_location(self, ctx: &Context) -> &Span

Get the span of a node

fn shortest_path( self, to: Self, ctx: &Context, edge_selection: EdgeSelection ) -> Option<Box<[Self]>>

The shortest path between this and a target node

impl PartialEq<GlobalNode> for GlobalNode

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for GlobalNode

impl Eq for GlobalNode

impl Sealed for GlobalNode

impl StructuralEq for GlobalNode

impl StructuralPartialEq for GlobalNode