Enum ValidationError

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

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: Node

RootWithEdges

The root node of the Hugr should not have any edges.

Fields

node: Node

WrongNumberOfPorts

The node ports do not match the operation signature.

Fields

node: Node

optype: OpType

actual: usize

expected: usize

dir: Direction

UnconnectedPort

A dataflow port is not connected.

Fields

node: Node

port: Port

port_kind: EdgeKind

TooManyConnections

A linear port is connected to more than one thing.

Fields

node: Node

port: Port

port_kind: EdgeKind

IncompatiblePorts

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

Fields

from: Node

from_port: Port

from_kind: EdgeKind

to: Node

to_port: Port

to_kind: EdgeKind

NoParent

The non-root node has no parent.

Fields

node: Node

InvalidParentOp

The parent node is not compatible with the child node.

Fields

child: Node

child_optype: OpType

parent: Node

parent_optype: OpType

allowed_children: OpTag

InvalidInitialChild

Invalid first/second child.

Fields

parent: Node

parent_optype: OpType

optype: OpType

expected: OpTag

position: &'static str

InvalidChildren

The children list has invalid elements.

Fields

parent: Node

parent_optype: OpType

source: ChildrenValidationError

InvalidEdges

The children graph has invalid edges.

Fields

parent: Node

parent_optype: OpType

source: EdgeValidationError

NonContainerWithChildren

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

Fields

node: Node

optype: OpType

ContainerWithoutChildren

The node must have children, but has none.

Fields

node: Node

optype: OpType

NotADag

The children of a node do not form a DAG.

Fields

node: Node

optype: OpType

InterGraphEdgeError(InterGraphEdgeError)

There are invalid inter-graph edges.

ExtensionError(ExtensionError)

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: Node

SignatureError

Error in a node signature

Fields

node: Node

op: OpName

cause: SignatureError

OpaqueOpError(OpaqueOpError)

Error in a ExtensionOp serialized as an Opaque.

ConstTypeError(ConstTypeError)

A Const contained a Value of unexpected Type.

Trait Implementations

impl Clone for ValidationError

fn clone(&self) -> ValidationError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ValidationError

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

Formats the value using the given formatter.

impl Display for ValidationError

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

Formats the value using the given formatter.

impl Error for ValidationError

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 From<ConstTypeError> for ValidationError

fn from(source: ConstTypeError) -> Self

Converts to this type from the input type.

impl From<ExtensionError> for ValidationError

fn from(source: ExtensionError) -> Self

Converts to this type from the input type.

impl From<InterGraphEdgeError> for ValidationError

fn from(source: InterGraphEdgeError) -> Self

Converts to this type from the input type.

impl From<OpaqueOpError> for ValidationError

fn from(source: OpaqueOpError) -> Self

Converts to this type from the input type.

impl From<ValidationError> for BuildError

fn from(source: ValidationError) -> Self

Converts to this type from the input type.

impl From<ValidationError> for LoadHugrError

fn from(source: ValidationError) -> Self

Converts to this type from the input type.

impl From<ValidationError> for PackageValidationError

fn from(value: ValidationError) -> Self

Converts to this type from the input type.

impl PartialEq for ValidationError

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