Enum budvm::FaultKind

pub enum FaultKind {
    StackOverflow,
    StackUnderflow,
    InvalidVariableIndex,
    InvalidArgumentIndex,
    InvalidVtableIndex,
    UnknownFunction {
        kind: ValueKind,
        name: Symbol,
    },
    TypeMismatch {
        message: String,
        expected: ValueKind,
        received: Value,
    },
    InvalidType {
        message: String,
        received: Value,
    },
    Dynamic(DynamicFault),
    ArgumentMissing(Symbol),
    TooManyArguments(Value),
    ValueCannotBeHashed(Value),
    ValueOutOfRange(&'static str),
}

An unexpected event within the virtual machine.

Variants

StackOverflow

An attempt to push a value to the stack was made after the stack has reached its capacity.

StackUnderflow

An attempt to pop a value off of the stack was made when no values were present in the current code’s stack frame.

InvalidVariableIndex

An invalid variable index was used.

InvalidArgumentIndex

An invalid argument index was used.

InvalidVtableIndex

An invalid vtable index was used.

UnknownFunction

Fields

kind: ValueKind

The kind of the value the function was called on.

name: Symbol

The name of the function being called.

A call was made to a function that does not exist.

TypeMismatch

Fields

message: String

The error message explaining the type mismatch.

These patterns will be replaced in message before being Displayed:

• @expected
• @received-value
• @received-kind

expected: ValueKind

The kind expected in this context.

received: Value

The value that caused an error.

A value type was unexpected in the given context.

InvalidType

Fields

message: String

The error message explaining the type mismatch.

These patterns will be replaced in message before being Displayed:

• @received-value
• @received-kind

received: Value

The value that caused an error.

An invalid value type was encountered.

Dynamic(DynamicFault)

An error arose from dynamic types.

ArgumentMissing(Symbol)

An argument that was expected to a function was not passed.

TooManyArguments(Value)

Too many arguments were passed to a function.

ValueCannotBeHashed(Value)

A value that does not support hashing was used as a key in a hash map.

ValueOutOfRange(&'static str)

A value was encountered that was out of range of valid values.

Implementations

impl FaultKind

pub fn invalid_type(message: impl Into<String>, received: Value) -> Self

An invalid type was encountered.

These patterns will be replaced in message before being Displayed:

• @received-value
• @received-kind

pub fn type_mismatch( message: impl Into<String>, expected: ValueKind, received: Value ) -> Self

An type mismatch occurred.

These patterns will be replaced in message before being Displayed:

• @expected
• @received-value
• @received-kind

pub fn dynamic<T: Debug + Display + 'static>(fault: T) -> Self

Returns a FaultKind::Dynamic.

Trait Implementations

impl Clone for FaultKind

fn clone(&self) -> FaultKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FaultKind

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

Formats the value using the given formatter.

impl Display for FaultKind

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

Formats the value using the given formatter.

impl Error for FaultKind

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

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, demand: &mut Demand<'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 FaultKind

fn from(io_err: Error) -> Self

Converts to this type from the input type.

impl<'a, Env, ReturnType> From<FaultKind> for Error<'a, Env, ReturnType>where Env: Environment,

fn from(fault: FaultKind) -> Self

Converts to this type from the input type.

impl<'a, Env, ReturnType> From<FaultKind> for Fault<'a, Env, ReturnType>where Env: Environment,

fn from(kind: FaultKind) -> Self

Converts to this type from the input type.

impl PartialEq<FaultKind> for FaultKind

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for FaultKind