Struct ErrorDetails 

pub struct ErrorDetails<'a> {
    pub source_name: Box<str>,
    pub source_content: &'a str,
    pub error_offset: u32,
    pub line_start: u32,
    pub line_end: u32,
    pub kind: Box<ErrorKind>,
    pub severity: Severity,
    pub labels: Vec<DiagnosticLabel>,
    pub notes: Vec<String>,
}

Contains detailed information about an error that occurred during parsing.

This struct contains the source name, source content, error offset, line start and end positions, and the kind of error. All errors now use the unified ErrorKind type.

Example usage:

use vb6parse::errors::{ErrorDetails, ErrorKind, Severity, LexerError};

let error_details = ErrorDetails {
    source_name: "example.cls".to_string().into_boxed_str(),
    source_content: "Some VB6 code here...",
    error_offset: 10,
    line_start: 1,
    line_end: 1,
    kind: Box::new(ErrorKind::Lexer(LexerError::UnknownToken { token: "???".to_string() })),
    severity: Severity::Error,
    labels: vec![],
    notes: vec![],
};
error_details.print();

Fields

source_name: Box<str>

The name of the source file where the error occurred.

source_content: &'a str

The content of the source file where the error occurred.

error_offset: u32

The offset in the source content where the error occurred.

Note: This is a u32 to reflect VB6’s 32-bit addressing limitations.

line_start: u32

The starting line number of the error.

Note: This is a u32 to reflect VB6’s 32-bit addressing limitations.

line_end: u32

The ending line number of the error.

Note: This is a u32 to reflect VB6’s 32-bit addressing limitations.

kind: Box<ErrorKind>

The kind of error that occurred. Boxed to reduce the size of Result<T, ErrorDetails> on the stack.

severity: Severity

The severity of this diagnostic (Error, Warning, or Note).

labels: Vec<DiagnosticLabel>

Additional labeled spans for multi-span diagnostics. This allows annotating multiple locations in the source code within a single error message.

notes: Vec<String>

Additional notes to provide context for this diagnostic. These are displayed after the main error message.

Implementations

impl<'a> ErrorDetails<'a>

pub fn basic<E>( source_name: Box<str>, source_content: &'a str, error_offset: u32, line_start: u32, line_end: u32, kind: E, severity: Severity, ) -> ErrorDetails<'a>

where E: Into<ErrorKind>,

Creates a basic ErrorDetails with no labels or notes.

This is a convenience constructor for the common case where only the basic error information is needed.

Accepts any error type that can be converted to ErrorKind, including layer-specific errors like LexerError, ModuleError, ProjectError, etc.

pub fn with_label(self, label: DiagnosticLabel) -> Self

Adds a labeled span to this error.

pub fn with_labels(self, labels: Vec<DiagnosticLabel>) -> Self

Adds multiple labeled spans to this error.

pub fn with_note(self, note: impl Into<String>) -> Self

Adds a note to this error.

pub fn with_notes(self, notes: Vec<String>) -> Self

Adds multiple notes to this error.

pub fn emit(self, ctx: &mut ParserContext<'a>)

Emit this error by pushing it to the provided parser context.

This is a terminal operation that consumes the error and adds it to the context’s error collection.

Example

use vb6parse::errors::{ParserContext, DiagnosticLabel, LexerError, Span};

let mut ctx = ParserContext::new("test.bas", "Dim x");
let span = Span::at(0, 1);
let label_span = Span::at(4, 1);

ctx.error_with(span, LexerError::UnknownToken { token: "x".to_string() })
    .with_label(DiagnosticLabel::new(label_span, "here"))
    .with_note("Consider using 'Integer' instead")
    .emit(&mut ctx);

impl ErrorDetails<'_>

pub fn print(&self)

Print the ErrorDetails using ariadne for formatting.

Example usage:

use vb6parse::errors::{ErrorDetails, ErrorKind, Severity, LexerError};

let error_details = ErrorDetails {
    source_name: "example.cls".to_string().into_boxed_str(),
    source_content: "Some VB6 code here...",
    error_offset: 10,
    line_start: 1,
    line_end: 1,
    kind: Box::new(ErrorKind::Lexer(LexerError::UnknownToken { token: "???".to_string() })),
    severity: Severity::Error,
    labels: vec![],
    notes: vec![],
};
error_details.print();

pub fn eprint(&self)

Eprint the ErrorDetails using ariadne for formatting.

Example usage:

use vb6parse::errors::{ErrorDetails, ErrorKind, Severity, LexerError};

let error_details = ErrorDetails {
    source_name: "example.cls".to_string().into_boxed_str(),
    source_content: "Some VB6 code here...",
    error_offset: 10,
    line_start: 1,
    line_end: 1,
    kind: Box::new(ErrorKind::Lexer(LexerError::UnknownToken {
        token: "???".to_string(),
    })),
    severity: Severity::Error,
    labels: vec![],
    notes: vec![],
};
error_details.eprint();

pub fn print_to_string(&self) -> Result<String, Box<dyn Error>>

Convert the ErrorDetails into a string using ariadne for formatting

Errors

This function will return an error if there is an issue converting the formatted report into a UTF-8 string.

Trait Implementations

impl<'a> Clone for ErrorDetails<'a>

fn clone(&self) -> ErrorDetails<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ErrorDetails<'a>

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

Formats the value using the given formatter.

impl Display for ErrorDetails<'_>

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

Formats the value using the given formatter.