Enum Error 

pub enum Error {
    Io(Error),
    Fmt(Error),
    ParseInt(ParseIntError),
    FreeCategory(FreeCategoryError),
    WidthMismatch {
        expected: Width,
        actual: Width,
    },
    TypeMismatch {
        expected: TypeName,
        actual: TypeName,
    },
    ClockDomainMismatch,
    UndefinedSignal {
        name: SignalName,
    },
    ImmatureSim {
        cycle: Cycle,
    },
    Overflow {
        width: Width,
    },
    UnsupportedInCircom(&'static str),
    CircomWidthOverflow {
        width: Width,
        field_bits: Width,
    },
}

The workspace-wide error enum.

Every fallible operation in hdl-cat-* returns Result<T, Error>. Variants either wrap an underlying error type or encode a domain-specific failure.

Examples

use hdl_cat_error::{Error, Width};

let e = Error::WidthMismatch {
    expected: Width::new(8),
    actual: Width::new(4),
};
assert_eq!(
    e.to_string(),
    "width mismatch: expected 8 bit(s), got 4 bit(s)",
);

Variants

Io(Error)

Underlying I/O failure.

Fmt(Error)

Underlying core::fmt failure (e.g. from a writer).

ParseInt(ParseIntError)

Underlying integer parse failure.

FreeCategory(FreeCategoryError)

A free-category IR construction error from comp-cat-rs.

WidthMismatch

A value did not fit its declared hardware width.

Fields

expected: Width

The width declared by the target type.

actual: Width

The width actually supplied.

TypeMismatch

A hardware value’s runtime type does not match the expected type.

Fields

expected: TypeName

The expected type’s display name.

actual: TypeName

The actual type’s display name.

ClockDomainMismatch

Two signals from different clock domains were composed.

UndefinedSignal

A signal referenced in an IR or codegen pass was never defined.

Fields

name: SignalName

The name that could not be resolved.

ImmatureSim

A simulation attempted to read a register before the first clock edge had advanced state beyond its initial value.

Fields

cycle: Cycle

The cycle at which the read was attempted.

Overflow

A value overflowed its declared range during arithmetic.

Fields

width: Width

The width of the operation that overflowed.

UnsupportedInCircom(&'static str)

An IR op has no Circom lowering in the current backend version.

The payload is a short static identifier (e.g. "add", "reg") naming the op and the reason the Circom emitter refused it. Combinational bitwise ops, Const, Slice, and Concat are supported in v1; arithmetic and stateful ops are scheduled for a follow-up.

CircomWidthOverflow

A Circom signal’s declared bit width exceeds the target field’s maximum safe width.

Circom’s scalar fields are prime of ~254 or ~64 bits depending on the target curve. An intermediate whose worst-case witness would exceed that width cannot be emitted without lowering through a Num2Bits gadget.

Fields

width: Width

The width of the signal the emitter was asked to produce.

field_bits: Width

The target field’s maximum safe bit width.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<Error> for Error

fn from(e: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(e: Error) -> Error

Converts to this type from the input type.

impl From<FreeCategoryError> for Error

fn from(e: FreeCategoryError) -> Error

Converts to this type from the input type.

impl From<ParseIntError> for Error

fn from(e: ParseIntError) -> Error

Converts to this type from the input type.