Struct CompileErrors 

pub struct CompileErrors { /* private fields */ }

A collection of compilation errors.

This type supports collecting multiple errors during compilation to provide users with more comprehensive diagnostics. Instead of stopping at the first error, the compiler can continue and report multiple issues at once.

Usage

Use CompileErrors when a compilation phase can detect multiple independent errors. For example, semantic analysis can report multiple type errors in different functions.

let mut errors = CompileErrors::new();
errors.push(CompileError::new(ErrorKind::TypeMismatch { ... }, span1));
errors.push(CompileError::new(ErrorKind::UndefinedVariable("x".into()), span2));

if !errors.is_empty() {
    return Err(errors);
}

Error Semantics

• An empty CompileErrors represents no errors (not a failure)
• A non-empty CompileErrors represents one or more compilation failures
• When converted to a single CompileError, the first error is used

Implementations

impl CompileErrors

pub fn new() -> Self

Create a new empty error collection.

pub fn from_error(error: CompileError) -> Self

Create an error collection from a single error.

pub fn push(&mut self, error: CompileError)

Add an error to the collection.

pub fn extend(&mut self, other: CompileErrors)

Extend this collection with errors from another collection.

pub fn is_empty(&self) -> bool

Returns true if there are no errors.

pub fn len(&self) -> usize

Returns the number of errors.

pub fn first(&self) -> Option<&CompileError>

Get the first error, if any.

pub fn iter(&self) -> impl Iterator<Item = &CompileError>

Iterate over all errors.

pub fn as_slice(&self) -> &[CompileError]

Get all errors as a slice.

pub fn into_result(self) -> Result<(), CompileErrors>

Check if the collection contains errors and return as a result.

Returns Ok(()) if empty, or Err(self) if there are errors.

pub fn into_result_with<T>(self, value: T) -> Result<T, CompileErrors>

Fail with these errors if non-empty, otherwise return the value.

This is useful for combining error checking with a result:

let output = SemaOutput { ... };
errors.into_result_with(output)

Trait Implementations

impl Clone for CompileErrors

fn clone(&self) -> CompileErrors

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompileErrors

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

Formats the value using the given formatter.

impl Default for CompileErrors

fn default() -> Self

Returns the “default value” for a type.

impl Display for CompileErrors

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

Formats the value using the given formatter.

impl Error for CompileErrors

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 From<CompileErrors> for CompileError

fn from(errors: CompileErrors) -> Self

Convert a collection to a single error.

Uses the first error in the collection. If the collection is empty, returns an internal error (this indicates a compiler bug).

impl From<DiagnosticWrapper<ErrorKind>> for CompileErrors

fn from(error: CompileError) -> Self

Converts to this type from the input type.

impl From<Vec<DiagnosticWrapper<ErrorKind>>> for CompileErrors

fn from(errors: Vec<CompileError>) -> Self

Converts to this type from the input type.

impl IntoIterator for CompileErrors

type Item = DiagnosticWrapper<ErrorKind>

The type of the elements being iterated over.

type IntoIter = IntoIter<DiagnosticWrapper<ErrorKind>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.