Enum LexError 

pub enum LexError {
    UnterminatedBlockComment {
        span: Span,
    },
    UnterminatedString {
        span: Span,
    },
    UnterminatedQuotedName {
        kind: QuotedNameKind,
        span: Span,
    },
    NulInName {
        span: Span,
    },
    IdOverflow {
        span: Span,
    },
    IntegerOverflow64 {
        span: Span,
    },
    IntegerOverflow128 {
        span: Span,
    },
    IntegerWidthOutOfRange {
        width: u64,
        max: u32,
        span: Span,
    },
    HexFpTooLarge {
        target: HexFpKind,
        span: Span,
    },
    UnknownToken {
        span: Span,
    },
    StraySlash {
        span: Span,
    },
}

All lexer-level failures.

Variants

UnterminatedBlockComment

Fields

span: Span

UnterminatedString

Fields

span: Span

UnterminatedQuotedName

Fields

kind: QuotedNameKind

span: Span

NulInName

Fields

span: Span

IdOverflow

Fields

span: Span

IntegerOverflow64

Fields

span: Span

IntegerOverflow128

Fields

span: Span

IntegerWidthOutOfRange

Fields

width: u64

max: u32

span: Span

HexFpTooLarge

Fields

target: HexFpKind

span: Span

UnknownToken

Fields

span: Span

StraySlash

Fields

span: Span

Implementations

impl LexError

pub fn span(&self) -> Span

The span the diagnostic should highlight. Useful for callers that want to render (line, column) without case-matching every variant.

Examples found in repository

examples/lex_file.rs (line 68)

fn report_error(path: &std::path::Path, sm: &SourceMap<'_>, err: &LexError) {
    let span = err.span();
    let (l, c) = sm.line_col(span.start);
    eprintln!("{path}:{l}:{c}: {err}", path = path.display());
    if let Some(line) = sm.line_text(l) {
        eprintln!("  | {}", String::from_utf8_lossy(line));
        let underline_len = (span.end.saturating_sub(span.start) as usize).max(1);
        eprintln!(
            "  | {pad}{caret}",
            pad = " ".repeat((c - 1) as usize),
            caret = "^".repeat(underline_len)
        );
    }
}

Trait Implementations

impl Clone for LexError

fn clone(&self) -> LexError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LexError

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

Formats the value using the given formatter.

impl Display for LexError

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

Formats the value using the given formatter.

impl Eq for LexError

impl Error for LexError

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

fn from(source: LexError) -> Self

Converts to this type from the input type.

impl Hash for LexError

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 LexError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LexError