Enum ParseError 

#[non_exhaustive]
pub enum ParseError {
    Lex(LexError),
    Expected {
        expected: String,
        loc: DiagLoc,
    },
    Redefinition {
        kind: SymbolKind,
        id: SymbolId,
        loc: DiagLoc,
    },
    UndefinedSymbol {
        kind: SymbolKind,
        id: SymbolId,
        loc: DiagLoc,
    },
    InvalidSlotId {
        source: AddError,
        loc: DiagLoc,
    },
    IntegerWidthOutOfRange {
        width: u64,
        max: u32,
        loc: DiagLoc,
    },
    Io(String),
}

Top-level parser error.

Variants are added phase-by-phase as new parser arms come online. Wording matches LLParser.cpp for the cases shipped today; structured fields let callers match without inspecting the rendered string.

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.

Lex(LexError)

The lexer rejected the next token.

Expected

LLParser::error site for “expected X” / “expected Y” diagnostics. expected carries the human-readable description LLParser would pass to tokError.

Fields

expected: String

loc: DiagLoc

Redefinition

redefinition of <symbol> — mirrors LLParser::checkValueID and the "redefinition of " diagnostic site in LLParser.cpp.

Fields

kind: SymbolKind

id: SymbolId

loc: DiagLoc

UndefinedSymbol

use of undefined ... — mirrors the "use of undefined " diagnostics that LLParser emits when a module-level forward reference is never satisfied. Carries the reference’s first-seen location so renderers can point at the use site.

Fields

kind: SymbolKind

id: SymbolId

loc: DiagLoc

InvalidSlotId

slot mapping rejected slot id — wraps a SlotAddError from crate::numbered_values::NumberedValues::add. Mirrors the assert(ID >= NextUnusedID) site that LLParser triggers when a .ll file uses a non-monotonic slot id.

Fields

source: AddError

loc: DiagLoc

IntegerWidthOutOfRange

bitwidth for integer type out of range — mirrors the upstream LLParser::parseType arm that rejects iN for N outside [1, MAX_INT_BITS].

Fields

width: u64

max: u32

loc: DiagLoc

Io(String)

I/O failure pulling source bytes. The lexer itself does not perform I/O; this is for callers using crate::read_to_owned-style helpers. The wrapped string is the Display form of the underlying std::io::Error; we don’t keep the std::io::Error itself because it lacks Clone/Eq/Hash, which the rest of ParseError derives.

Implementations

impl ParseError

pub fn loc(&self) -> Option<DiagLoc>

The diagnostic location to highlight, when the variant carries one.

Examples found in repository

examples/parse_file.rs (line 71)

fn report_error(path: &Path, src: &[u8], err: &ParseError) {
    let sm = SourceMap::new(src);
    let span = err.loc().map(|l| l.span).unwrap_or(Span::new(0, 0));
    let (line, col) = sm.line_col(span.start);
    eprintln!("{path}:{line}:{col}: {err}", path = path.display());
    if let Some(line_bytes) = sm.line_text(line) {
        eprintln!("  | {}", String::from_utf8_lossy(line_bytes));
        let underline_len = (span.end.saturating_sub(span.start) as usize).max(1);
        eprintln!(
            "  | {pad}{caret}",
            pad = " ".repeat((col - 1) as usize),
            caret = "^".repeat(underline_len)
        );
    }
}

Trait Implementations

impl Clone for ParseError

fn clone(&self) -> ParseError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseError

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

Formats the value using the given formatter.

impl Display for ParseError

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

Formats the value using the given formatter.

impl Eq for ParseError

impl Error for ParseError

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<Error> for ParseError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<LexError> for ParseError

fn from(source: LexError) -> Self

Converts to this type from the input type.

impl Hash for ParseError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ParseError

fn eq(&self, other: &ParseError) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ParseError