Enum RuntimeInvariantViolation 

pub enum RuntimeInvariantViolation {
    RuntimeCycle {
        nodes: BTreeSet<TaskId>,
        offending_edge: (TaskId, TaskId),
    },
    OutputOverlap {
        first_task: TaskId,
        second_task: TaskId,
        shared_path: CanonicalPath,
    },
}

A workspace-level invariant the scheduler detected at runtime.

Each variant carries enough information to produce a diagnostic shape-equivalent to the static DAG-014 / DAG-016 error it is the runtime analogue of: a cycle’s node set and the offending edge; an overlap’s two task identities and the shared path.

Variants

RuntimeCycle

EXEC-019 runtime cycle: a length-≥2 cycle in the union of hard, soft, and producer-matching edges, discovered when a newly-materialised output added a runtime producer-matching edge that closed the cycle.

Fields

nodes: BTreeSet<TaskId>

Every task identified as a member of the cycle.

offending_edge: (TaskId, TaskId)

The newly-added producer-matching edge whose addition closed the cycle (predecessor, successor).

OutputOverlap

EXEC-020 runtime output overlap: two tasks have both materialised the same workspace-absolute path.

Fields

first_task: TaskId

The task that claimed the path first (chronologically in the run’s completion order).

second_task: TaskId

The task whose materialisation discovered the pre-existing claim.

shared_path: CanonicalPath

The path both tasks materialised.

Trait Implementations

impl Clone for RuntimeInvariantViolation

fn clone(&self) -> RuntimeInvariantViolation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuntimeInvariantViolation

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

Formats the value using the given formatter.

impl PartialEq for RuntimeInvariantViolation

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for RuntimeInvariantViolation

impl StructuralPartialEq for RuntimeInvariantViolation