Enum Error

#[non_exhaustive]
pub enum Error<E = Infallible> {
    CloseError,
    BuildError,
    CloseAtError,
    Overflow,
    MissingNode(usize),
    Flavor(E),
}

Errors raised while building a tree.

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.

CloseError

Error raised by Builder::close if there currently is no node being built.

Examples

use syntree::{Builder, Error};

let mut tree = Builder::new();

tree.open("root")?;
tree.close()?;

// Syntax::Root and Syntax::Child is left open.
assert_eq!(tree.close(), Err(Error::CloseError));

BuildError

Error raised by Builder::build if the tree isn’t correctly balanced.

Examples

use syntree::{Builder, Error};

let mut tree = Builder::new();

tree.open("number")?;
tree.token("lit", 3)?;
tree.close()?;

tree.open("number")?;

// Syntax::Number is left open.
assert_eq!(tree.build(), Err(Error::BuildError));

CloseAtError

Error raised by Builder::close_at if we’re not trying to close at a sibling node.

Examples

use syntree::{Builder, Error};

let mut tree = Builder::new();

let c = tree.checkpoint()?;

tree.open("child")?;
tree.token("token", 3)?;

assert_eq!(tree.close_at(&c, "operation"), Err(Error::CloseAtError));

Overflow

Numerical overflow.

This only happens under extreme circumstances or if a feature is enabled which narrows the width of an identifier to the degree that this error is easier to accomplish.

Examples

This is an example where we’re trying to build a really small tree using u8 pointers:

use syntree::{Builder, Error};

syntree::flavor! {
    struct CustomFlavor {
        type Index = u32;
        type Width = u8;
    }
}

let mut tree: Builder<_, CustomFlavor> = Builder::new_with();

for d in 0..u8::MAX {
    tree.token(d, 1)?;
}

assert_eq!(tree.token(255, 1), Err(Error::Overflow));

MissingNode(usize)

The node of the given id is missing.

Examples

The following showcases what could happen if you mix checkpoints from two compatible trees:

use syntree::{Builder, Error};

let mut a = Builder::new();
let mut b = Builder::new();

b.open("child")?;
b.close()?;

let c = b.checkpoint()?;

assert_eq!(a.close_at(&c, "operation"), Err(Error::MissingNode(0)));

Flavor(E)

An error raised by the particular Flavor in use.

Trait Implementations

impl<E: Clone> Clone for Error<E>

fn clone(&self) -> Error<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for Error<E>

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

Formats the value using the given formatter.

impl<E> Display for Error<E>

where E: Display,

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

Formats the value using the given formatter.

impl<E> Error for Error<E>

where E: 'static + 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<E> From<E> for Error<E>

fn from(error: E) -> Self

Converts to this type from the input type.

impl<E: PartialEq> PartialEq for Error<E>

fn eq(&self, other: &Error<E>) -> 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<E: Copy> Copy for Error<E>

impl<E: Eq> Eq for Error<E>

impl<E> StructuralPartialEq for Error<E>