Enum rustc_data_structures::obligation_forest::NodeState

enum NodeState {
    Pending,
    Success,
    Waiting,
    Done,
    Error,
}

The state of one node in some tree within the forest. This represents the current state of processing for the obligation (of type O) associated with this node.

The non-Error state transitions are as follows.

(Pre-creation)
 |
 |     register_obligation_at() (called by process_obligations() and
 v                               from outside the crate)
Pending
 |
 |     process_obligations()
 v
Success
 |  ^
 |  |  mark_successes()
 |  v
 |  Waiting
 |
 |     process_cycles()
 v
Done
 |
 |     compress()
 v
(Removed)

The Error state can be introduced in several places, via error_at().

Outside of ObligationForest methods, nodes should be either Pending or Waiting.

Variants

Pending

This obligation has not yet been selected successfully. Cannot have subobligations.

Success

This obligation was selected successfully, but may or may not have subobligations.

Waiting

This obligation was selected successfully, but it has a pending subobligation.

Done

This obligation, along with its subobligations, are complete, and will be removed in the next collection.

Error

This obligation was resolved to an error. It will be removed by the next compression step.

Trait Implementations

impl Clone for NodeState

fn clone(&self) -> NodeState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeState

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

Formats the value using the given formatter.

impl PartialEq for NodeState

fn eq(&self, other: &NodeState) -> 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 NodeState

impl Eq for NodeState

impl StructuralPartialEq for NodeState

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• Pending: 0 bytes
• Success: 0 bytes
• Waiting: 0 bytes
• Done: 0 bytes
• Error: 0 bytes