Enum RuntimeError 

pub enum RuntimeError {
    VariableNotFound(String, TokenRange),
    TypeMismatch {
        expected: String,
        found: String,
        range: TokenRange,
    },
    ValidationError(String, TokenRange),
    DivisionByZero(TokenRange),
    FunctionNotFound(String, TokenRange),
    CircularReference {
        cycle: Vec<String>,
        range: TokenRange,
    },
    UnsupportedOperator(String, TokenRange),
    InvalidIdentifier(String, TokenRange),
    IoError(String),
    ModuleNotFound(String, SourceSpan),
    ModuleParseError {
        path: String,
        message: String,
        range: SourceSpan,
    },
    CircularImport(Vec<String>, SourceSpan),
    NumericOverflow(TokenRange),
    StepLimitExceeded {
        limit: Option<u64>,
        range: TokenRange,
    },
    RecursionLimitExceeded {
        limit: usize,
        range: TokenRange,
    },
    ValueTooLarge {
        limit: usize,
        actual: usize,
        range: TokenRange,
    },
    IndexOutOfBounds {
        range: TokenRange,
    },
    EmptyList {
        range: TokenRange,
    },
    CapabilityDenied {
        cap_bit: Option<u32>,
        reason: String,
        range: TokenRange,
    },
    NoMainSignature {
        range: TokenRange,
    },
    MissingMainArg {
        name: String,
        range: TokenRange,
    },
    UnexpectedMainArg {
        name: String,
        range: TokenRange,
    },
    MainArgTypeMismatch {
        name: String,
        expected: String,
        found: String,
        range: TokenRange,
    },
    MainReturnTypeMismatch {
        expected: String,
        found: String,
        range: TokenRange,
    },
    Unsupported {
        reason: String,
    },
    RemoteImportFailed {
        payload: Box<RemoteImportFailure>,
        range: TokenRange,
    },
    RemoteImportDenied {
        payload: Box<RemoteImportDenial>,
        range: TokenRange,
    },
    RemoteImportHashMismatch {
        payload: Box<RemoteImportHashMismatchDetail>,
        range: TokenRange,
    },
    ImportHashMismatch {
        payload: Box<ImportHashMismatchDetail>,
        range: TokenRange,
    },
    ImportHashUnknownAlgorithm {
        path: String,
        algorithm: String,
        range: TokenRange,
    },
    ImportHashInvalidHex {
        path: String,
        algorithm: String,
        expected_len: usize,
        got_len: usize,
        range: TokenRange,
    },
}

Variants

VariableNotFound(String, TokenRange)

TypeMismatch

Fields

expected: String

found: String

range: TokenRange

ValidationError(String, TokenRange)

DivisionByZero(TokenRange)

FunctionNotFound(String, TokenRange)

CircularReference

Fields

cycle: Vec<String>

Path segments that form the cycle, in declaration order.

range: TokenRange

UnsupportedOperator(String, TokenRange)

InvalidIdentifier(String, TokenRange)

IoError(String)

ModuleNotFound(String, SourceSpan)

ModuleParseError

Fields

path: String

message: String

range: SourceSpan

CircularImport(Vec<String>, SourceSpan)

NumericOverflow(TokenRange)

StepLimitExceeded

Step / resource budget exhausted. The tree-walker fills limit with the configured max_steps; the compiled backends trap with the numeric tag only and leave limit as None.

Fields

limit: Option<u64>

The max_steps budget that was crossed, when the denying backend carries it (tree-walk). None on the compiled trap path, which only knows that the budget was exceeded.

range: TokenRange

RecursionLimitExceeded

Fields

limit: usize

range: TokenRange

ValueTooLarge

Fields

limit: usize

actual: usize

range: TokenRange

IndexOutOfBounds

Phase 4.c-2: an index / range operation walked off the end of a String / List receiver. Both backends share this variant — the tree-walker raises it from xs[i] style accessors, the wasm AOT path raises it from substring / similar stdlib builders when the caller-supplied bounds exceed the receiver’s length.

Fields

range: TokenRange

EmptyList

Phase 4.c-2: a reducer that requires at least one element (list_int_max, future head / last, …) was called on an empty list. Carries the call-site source range so the diagnostic points at the offending expression rather than at the stdlib body itself.

Fields

range: TokenRange

CapabilityDenied

A guarded native-fn / #import was denied because the host did not grant a required capability. Produced by every backend: the tree-walker fills a descriptive reason (and the bit, when it has one); the compiled trap paths carry only the numeric cap_bit and a generic reason.

Fields

cap_bit: Option<u32>

Capability bit index that was denied, when the denying backend carries it (compiled trap path; tree-walk native-fn dispatch). None for FS-resolver denials that map to no single bit, or when the compiled trap lost the bit.

reason: String

Human-readable reason. Tree-walk fills the native-fn / import detail; compiled backends fill “host-fn requires capability bit N”.

range: TokenRange

NoMainSignature

Fields

range: TokenRange

MissingMainArg

Fields

name: String

range: TokenRange

UnexpectedMainArg

Fields

name: String

range: TokenRange

MainArgTypeMismatch

Fields

name: String

expected: String

found: String

range: TokenRange

MainReturnTypeMismatch

Fields

expected: String

found: String

range: TokenRange

Unsupported

Phase 8: the active backend cannot satisfy the requested Evaluator method. The wasm-AOT backend uses this to refuse eval / eval_root / force_thunk / invoke_closure because its AST is consumed at compile time and the runtime only knows how to drive the precompiled run_main entry. Host-side hooks that depend on lazy / first-class-closure semantics need to either switch to the tree-walker or be reformulated.

Fields

reason: String

Human-readable explanation of why the backend cannot honour the call. Free-form so each backend can describe its own constraint (e.g. “wasm-aot has no AST at runtime”).

RemoteImportFailed

v3+ a-3: remote #import "https://..." resolved an URL but the HTTP fetch (DNS / connect / TLS / non-2xx status / body read) failed. The payload is boxed so the variant does not bloat the RuntimeError enum past clippy’s result_large_err threshold — callers should use the url() / cause() accessors below, or destructure *payload.

Fields

payload: Box<RemoteImportFailure>

range: TokenRange

RemoteImportDenied

v3+ a-3: remote #import "https://..." was rejected before the fetch ran because the active sandbox forbids network egress (no --trust / no Capabilities::network).

Fields

payload: Box<RemoteImportDenial>

range: TokenRange

RemoteImportHashMismatch

v3+ a-3: an explicit integrity hash was supplied alongside a remote #import, and the fetched body’s sha256 did not match. The pinning syntax itself is not wired in this phase, but the variant ships so future syntax work (or an out-of-band lockfile) can reuse the error surface without churning the enum.

Fields

payload: Box<RemoteImportHashMismatchDetail>

range: TokenRange

ImportHashMismatch

review-improvement-174 (v3++ b-2 fix): the evaluator’s #import path computed the loaded module body’s digest and it did not match the inline sha256:"..." integrity pin written on the directive.

Distinct from Self::RemoteImportHashMismatch so operators can tell apart “remote fetch produced an unexpected body” (caught by RemoteHttpResolver / analyzer) from “evaluator was handed a pre-resolved module body that disagrees with its pin” — the latter is the analyzer-bypass attack vector this fix closes.

Fields

payload: Box<ImportHashMismatchDetail>

range: TokenRange

ImportHashUnknownAlgorithm

review-improvement-174: the inline pin on a #import carried an algorithm identifier (<algo>:"...") the evaluator does not know how to compute. The analyzer surfaces the same condition as a WorkspaceDiagnostic::ImportHashUnknownAlgorithm; this variant mirrors it for the analyzer-bypass path so the evaluator never silently treats an unknown algorithm as “no pin”.

Fields

path: String

algorithm: String

range: TokenRange

ImportHashInvalidHex

review-improvement-174: the inline pin hex was malformed (wrong length, non-hex character). Mirrors the analyzer’s WorkspaceDiagnostic::ImportHashInvalidHex for the evaluator-direct path; a malformed pin is rejected fail-closed because we cannot compare against gibberish.

Fields

path: String

algorithm: String

expected_len: usize

got_len: usize

range: TokenRange

Trait Implementations

impl Clone for RuntimeError

fn clone(&self) -> RuntimeError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuntimeError

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

Formats the value using the given formatter.

impl Diagnostic for RuntimeError

fn code(&self) -> Option<Box<dyn Display + '_>>

Unique diagnostic code that can be used to look up more information about this Diagnostic. Ideally also globally unique, and documented in the toplevel crate’s documentation for easy searching. Rust path format (foo::bar::baz) is recommended, but more classic codes like E0123 or enums will work just fine.

fn help(&self) -> Option<Box<dyn Display + '_>>

Additional help text related to this Diagnostic. Do you have any advice for the poor soul who’s just run into this issue?

fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>>

Labels to apply to this Diagnostic’s Diagnostic::source_code

fn severity(&self) -> Option<Severity>

Diagnostic severity. This may be used by ReportHandlers to change the display format of this diagnostic.

fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

URL to visit for a more detailed explanation/help about this Diagnostic.

fn source_code(&self) -> Option<&dyn SourceCode>

Source code to apply this Diagnostic’s Diagnostic::labels to.

fn related<'a>( &'a self, ) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>>

Additional related Diagnostics.

fn diagnostic_source(&self) -> Option<&dyn Diagnostic>

The cause of the error.

impl Display for RuntimeError

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

Formats the value using the given formatter.

impl Error for RuntimeError

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.