Enum ValidationError

#[non_exhaustive]
pub enum ValidationError<N: HugrNode> {
    RootNotRoot {
        node: N,
    },
    WrongNumberOfPorts {
        node: N,
        optype: OpType,
        actual: usize,
        expected: usize,
        dir: Direction,
    },
    UnconnectedPort {
        node: N,
        port: Port,
        port_kind: EdgeKind,
    },
    TooManyConnections {
        node: N,
        port: Port,
        port_kind: EdgeKind,
    },
    IncompatiblePorts {
        from: N,
        from_port: Port,
        from_kind: EdgeKind,
        to: N,
        to_port: Port,
        to_kind: EdgeKind,
    },
    NoParent {
        node: N,
    },
    InvalidParentOp {
        child: N,
        child_optype: OpType,
        parent: N,
        parent_optype: OpType,
        allowed_children: OpTag,
    },
    InvalidInitialChild {
        parent: N,
        parent_optype: OpType,
        optype: OpType,
        expected: OpTag,
        position: &'static str,
    },
    InvalidChildren {
        parent: N,
        parent_optype: OpType,
        source: ChildrenValidationError<N>,
    },
    InvalidEdges {
        parent: N,
        parent_optype: OpType,
        source: EdgeValidationError<N>,
    },
    NonContainerWithChildren {
        node: N,
        optype: OpType,
    },
    ContainerWithoutChildren {
        node: N,
        optype: OpType,
    },
    NotADag {
        node: N,
        optype: OpType,
    },
    InterGraphEdgeError(InterGraphEdgeError<N>),
    ExtensionError(ExtensionError),
    ExtensionsNotInferred {
        node: N,
    },
    SignatureError {
        node: N,
        op: OpName,
        cause: SignatureError,
    },
    OpaqueOpError(OpaqueOpError<N>),
    ConstTypeError(ConstTypeError),
    EntrypointNotContainer {
        node: N,
        optype: OpType,
    },
}

Errors that can occur while validating a Hugr.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

RootNotRoot

The root node of the Hugr is not a root in the hierarchy.

Fields

node: N

WrongNumberOfPorts

The node ports do not match the operation signature.

Fields

node: N

optype: OpType

actual: usize

expected: usize

dir: Direction

UnconnectedPort

A dataflow port is not connected.

Fields

node: N

port: Port

port_kind: EdgeKind

TooManyConnections

A linear port is connected to more than one thing.

Fields

node: N

port: Port

port_kind: EdgeKind

IncompatiblePorts

Connected ports have different types, or non-unifiable types.

Fields

from: N

from_port: Port

from_kind: EdgeKind

to: N

to_port: Port

to_kind: EdgeKind

NoParent

The non-root node has no parent.

Fields

node: N

InvalidParentOp

The parent node is not compatible with the child node.

Fields

child: N

child_optype: OpType

parent: N

parent_optype: OpType

allowed_children: OpTag

InvalidInitialChild

Invalid first/second child.

Fields

parent: N

parent_optype: OpType

optype: OpType

expected: OpTag

position: &'static str

InvalidChildren

The children list has invalid elements.

Fields

parent: N

parent_optype: OpType

source: ChildrenValidationError<N>

InvalidEdges

The children graph has invalid edges.

Fields

parent: N

parent_optype: OpType

source: EdgeValidationError<N>

NonContainerWithChildren

The node operation is not a container, but has children.

Fields

node: N

optype: OpType

ContainerWithoutChildren

The node must have children, but has none.

Fields

node: N

optype: OpType

NotADag

The children of a node do not form a DAG.

Fields

node: N

optype: OpType

InterGraphEdgeError(InterGraphEdgeError<N>)

There are invalid inter-graph edges.

ExtensionError(ExtensionError)

👎Deprecated: Never returned since hugr-core-v0.20.0

There are errors in the extension deltas.

ExtensionsNotInferred

A node claims to still be awaiting extension inference. Perhaps it is not acted upon by inference.

Fields

node: N

SignatureError

Error in a node signature

Fields

node: N

op: OpName

cause: SignatureError

OpaqueOpError(OpaqueOpError<N>)

Error in a ExtensionOp serialized as an Opaque.

ConstTypeError(ConstTypeError)

A Const contained a Value of unexpected Type.

EntrypointNotContainer

The HUGR entrypoint must be a region container.

Fields

node: N

optype: OpType

Trait Implementations

impl<N: Clone + HugrNode> Clone for ValidationError<N>

fn clone(&self) -> ValidationError<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug + HugrNode> Debug for ValidationError<N>

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

Formats the value using the given formatter.

impl<N> Display for ValidationError<N>

where N: Display + HugrNode, ChildrenValidationError<N>: Display, EdgeValidationError<N>: Display, InterGraphEdgeError<N>: Display, OpaqueOpError<N>: Display,

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

Formats the value using the given formatter.

impl<N: HugrNode> Error for ValidationError<N>

where ChildrenValidationError<N>: Error + 'static, EdgeValidationError<N>: Error + 'static, InterGraphEdgeError<N>: Error, OpaqueOpError<N>: Error, Self: Debug + Display,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<N: HugrNode> From<ConstTypeError> for ValidationError<N>

fn from(source: ConstTypeError) -> Self

Converts to this type from the input type.

impl<N: HugrNode> From<ExtensionError> for ValidationError<N>

fn from(source: ExtensionError) -> Self

Converts to this type from the input type.

impl<N: HugrNode> From<InterGraphEdgeError<N>> for ValidationError<N>

fn from(source: InterGraphEdgeError<N>) -> Self

Converts to this type from the input type.

impl<N: HugrNode> From<OpaqueOpError<N>> for ValidationError<N>

fn from(source: OpaqueOpError<N>) -> Self

Converts to this type from the input type.

impl From<ValidationError<Node>> for BuildError

fn from(source: ValidationError<Node>) -> Self

Converts to this type from the input type.

impl From<ValidationError<Node>> for PackageValidationError

fn from(value: ValidationError<Node>) -> Self

Converts to this type from the input type.

impl<N: PartialEq + HugrNode> PartialEq for ValidationError<N>

fn eq(&self, other: &ValidationError<N>) -> 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<N: HugrNode> StructuralPartialEq for ValidationError<N>