Enum Error 

#[non_exhaustive]
pub enum Error {
    SyntaxError {
        message: String,
        incomplete_input: bool,
    },
    RuntimeError(String),
    MemoryError(String),
    FromLuaConversionError {
        from: &'static str,
        to: String,
        message: Option<String>,
    },
    ToLuaConversionError {
        from: &'static str,
        to: &'static str,
        message: Option<String>,
    },
    UserDataTypeMismatch,
    UserDataDestructed,
    CallbackDestructed,
    CallbackError {
        traceback: String,
        cause: Arc<Error>,
    },
    UserDataBorrowError,
    UserDataBorrowMutError,
    CoroutineUnresumable,
    MismatchedRegistryKey,
    RecursiveMutCallback,
    PreviouslyResumedPanic,
    ExternalError(Arc<dyn StdError + Send + Sync>),
}

Errors that can occur when interacting with the Lua engine.

The variant set mirrors the commonly used part of mlua’s Error. It is marked #[non_exhaustive] (like mlua’s) so new variants can be added without a breaking change.

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.

SyntaxError

A Lua syntax (compile/parse) error.

Fields

message: String

The human-readable message produced by the compiler.

incomplete_input: bool

Whether the input looked like it was merely incomplete (e.g. an unterminated block). Always false for now; reserved for REPL use.

RuntimeError(String)

A Lua runtime error (error(..), a failed assert, a type error, or a Rust callback returning Err).

MemoryError(String)

A memory allocation error reported by the VM.

FromLuaConversionError

A value could not be converted from a Lua value into the requested Rust type.

Fields

from: &'static str

The Lua type name of the source value.

to: String

The name of the target Rust type.

message: Option<String>

Optional extra detail.

ToLuaConversionError

A Rust value could not be converted into a Lua value.

Fields

from: &'static str

The name of the source Rust type.

to: &'static str

The Lua type name being targeted.

message: Option<String>

Optional extra detail.

UserDataTypeMismatch

A UserData value was accessed as the wrong concrete type.

UserDataDestructed

A UserData value was used after it had been destructed (dropped).

CallbackDestructed

Either a callback or a userdata method was called, but the callback or userdata had been destructed.

This happens when a function/userdata created via Lua::scope is used after the scope has ended (so the scope has already dropped the boxed closure / invalidated the Lua object). Mirrors mlua::Error::CallbackDestructed.

CallbackError

A Rust callback returned Err, which was raised as a Lua error and then caught at a protected-call boundary (e.g. Function::call). The original error is preserved in cause. Mirrors mlua::Error::CallbackError.

luaur-rt only produces this variant for callback errors that carry structured meaning across the Lua boundary (currently Error::CallbackDestructed and Error::UserDataDestructed); plain string callback errors continue to surface as Error::RuntimeError for backward compatibility.

Fields

traceback: String

A Lua call-stack traceback (empty when luaur-rt does not capture one).

cause: Arc<Error>

The original error returned by the Rust callback.

UserDataBorrowError

A UserData could not be immutably borrowed because it is already mutably borrowed.

UserDataBorrowMutError

A UserData could not be mutably borrowed because it is already borrowed.

CoroutineUnresumable

A coroutine (crate::Thread) could not be resumed because it has finished, errored, or is currently running. Mirrors mlua::Error::CoroutineUnresumable.

MismatchedRegistryKey

A crate::RegistryKey was used with a crate::Lua that does not own it. Mirrors mlua::Error::MismatchedRegistryKey.

RecursiveMutCallback

A create_function_mut / create_userdata mutable callback was invoked re-entrantly while a previous invocation still held the &mut. The inner RefCell borrow failed, which we surface as this variant rather than allowing mutable aliasing. Mirrors mlua::Error::RecursiveMutCallback.

PreviouslyResumedPanic

A Rust panic was raised across a pcall boundary, caught and resumed once; a later attempt to re-raise/observe it failed because the panic was already resumed. Mirrors mlua::Error::PreviouslyResumedPanic.

ExternalError(Arc<dyn StdError + Send + Sync>)

An error originating outside Lua, wrapped via Error::external.

Implementations

impl Error

pub fn runtime<S: Display>(message: S) -> Self

Create a Error::RuntimeError from any displayable message.

Mirrors mlua::Error::runtime.

pub fn downcast_ref<T: StdError + 'static>(&self) -> Option<&T>

Try to view the wrapped external error as a concrete type T.

Mirrors the common mlua::Error::downcast_ref use: only Error::ExternalError carries a wrapped error to downcast.

pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Self

Wrap an arbitrary std::error::Error as an Error::ExternalError.

Mirrors mlua::Error::external: if the input is already a luaur Error, it is preserved as-is rather than re-wrapped.

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn StdError + '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<&str> for Error

fn from(msg: &str) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<String> for Error

fn from(msg: String) -> Self

Converts to this type from the input type.

impl FromLua for Error

fn from_lua(value: Value, _lua: &Lua) -> Result<Self>

Perform the conversion.

fn from_lua_arg( arg: Value, _i: usize, _to: Option<&str>, lua: &Lua, ) -> Result<Self>

Convert an argument at 1-based position i. The default forwards to FromLua::from_lua; specific impls can produce nicer messages. Mirrors mlua::FromLua::from_lua_arg.

impl IntoLua for Error

fn into_lua(self, _lua: &Lua) -> Result<Value>

Perform the conversion.