Struct Handler 

pub struct Handler { /* private fields */ }

A handler with which you can emit diagnostics.

Implementations

impl Handler

pub fn from_parts( errors: Vec<CompileError>, warnings: Vec<CompileWarning>, infos: Vec<CompileInfo>, ) -> Self

pub fn emit_err(&self, err: CompileError) -> ErrorEmitted

Emit the error err.

pub fn cancel(&self) -> ErrorEmitted

pub fn emit_warn(&self, warn: CompileWarning)

Emit the warning warn.

pub fn emit_info(&self, info: CompileInfo)

Emit the info info.

pub fn has_errors(&self) -> bool

pub fn find_error( &self, f: impl FnMut(&&CompileError) -> bool, ) -> Option<CompileError>

pub fn has_warnings(&self) -> bool

pub fn scope<T>( &self, f: impl FnOnce(&Handler) -> Result<T, ErrorEmitted>, ) -> Result<T, ErrorEmitted>

Aggregate errors emitted when running f.

Runs f in a fresh error-collecting scope, returning f’s result, or an aggregated ErrorEmitted if any error was emitted while running f.

A fresh, scoped Handler is passed to f. After f returns, its errors are appended to self. If at least one error was emitted into the scoped handler, the scope returns Err(ErrorEmitted) regardless of what f returned; otherwise it returns f’s result.

Swallowing errors within a scope is intended

Because the scope aggregates every error emitted into the scoped handler, code inside f should keep going after a failing sub-operation instead of short-circuiting on the first error. Swallowing an individual sub-operation’s Result and continuing with the next one is therefore the intended pattern. Independent sub-operations each get to report their own diagnostics, so the user sees all of them at once rather than only the first.

When iterating over a collection, use fold together with unwrap_or_default (rather than try_fold with ?) so that every element is still processed:

handler.scope(|handler| {
    // Each element's error is swallowed but stays captured by the scope, so
    // sibling elements can also report their diagnostics.
    Ok(items.iter_mut().fold(HasChanges::No, |has_changes, item| {
        has_changes | item.do_something(handler).unwrap_or_default()
    }))
})

For a fixed set of sub-operations, sway_core’s has_changes_scoped! macro applies the same swallow-and-continue behavior.

Use ? only when a later step genuinely depends on an earlier step succeeding, i.e. when continuing would panic or produce misleading cascade errors.

Note that swallowing an ErrorEmitted is only sound inside a scope (or with a scope somewhere up the call stack). Outside a scope, a swallowed error is lost from the returned Result even though it was emitted.

pub fn consume( self, ) -> (Vec<CompileError>, Vec<CompileWarning>, Vec<CompileInfo>)

Extract all the diagnostics from this handler.

pub fn append(&self, other: Handler) -> Option<ErrorEmitted>

pub fn dedup(&self)

pub fn retain_err<F>(&self, f: F)

where F: FnMut(&CompileError) -> bool,

Retains only the elements specified by the predicate.

In other words, remove all elements e for which f(&e) returns false. This method operates in place, visiting each element exactly once in the original order, and preserves the order of the retained elements.

pub fn map_and_emit_errors_from( &self, other: Handler, f: impl FnMut(CompileError) -> Option<CompileError>, ) -> Result<(), ErrorEmitted>

Trait Implementations

impl Clone for Handler

fn clone(&self) -> Handler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Handler

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

Formats the value using the given formatter.

impl Default for Handler

fn default() -> Handler

Returns the “default value” for a type.