Struct SyntaxError 

pub struct SyntaxError {
    pub offset: usize,
    pub line: usize,
    pub column: usize,
    pub expected: Vec<String>,
    pub found: Option<char>,
    pub line_text: String,
}

A syntax error, with the position in the document it was found at.

The position is the furthest one the parser reached, which is the character the document stops making sense at rather than the point the last alternative gave up on.

Examples

use links_notation::{parse_lino, ParseError};

let error = parse_lino("ci_gate x\nstage: rust: nextest\n").unwrap_err();
let ParseError::SyntaxError(error) = error else { panic!("expected a syntax error") };
assert_eq!((error.line, error.column), (2, 12));
assert_eq!(error.found, Some(':'));

Fields

offset: usize

Byte offset of the offending position from the start of the document.

line: usize

Line the offending position is on, counted from 1.

column: usize

Column the offending position is at, in characters, counted from 1.

expected: Vec<String>

What could have continued the document at this position. Empty when the parser stopped somewhere it names no expectation for.

found: Option<char>

The character found instead, or None at the end of the document.

line_text: String

The offending line, as written, without its line ending.

Implementations

impl SyntaxError

pub fn summary(&self) -> String

The one-line summary: where the parser stopped, what could have stood there and what does.

Examples

use links_notation::{parse_lino, ParseError};

let ParseError::SyntaxError(error) = parse_lino("a: b: c").unwrap_err() else {
    panic!("expected a syntax error")
};
assert_eq!(
    error.summary(),
    r#"line 1, column 5: expected "(", a reference or end of line, found ":""#
);

pub fn snippet(&self) -> String

The offending line with a caret under the offending column, quoted the way rustc quotes source.

A long line is shown as a window around the caret, so the message stays the same size whether the document has ten lines or fifteen hundred.

Examples

use links_notation::{parse_lino, ParseError};

let ParseError::SyntaxError(error) = parse_lino("a: b: c").unwrap_err() else {
    panic!("expected a syntax error")
};
assert_eq!(error.snippet(), "1 | a: b: c\n  |     ^");

Trait Implementations

impl Clone for SyntaxError

fn clone(&self) -> SyntaxError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyntaxError

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

Formats the value using the given formatter.

impl Display for SyntaxError

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

Formats the value using the given formatter.

impl Eq for SyntaxError

impl Error for SyntaxError

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 PartialEq for SyntaxError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SyntaxError