Struct ParseError 

pub struct ParseError { /* private fields */ }

A parse that reported at least one error.

There is no AST to carry: the parser returns no tree once it has reported an error, so only the diagnostics survive.

Implementations

impl ParseError

pub fn diagnostics(&self) -> &[ResolvedDiagnostic]

Every diagnostic recorded during the parse, in emission order.

pub fn error_count(&self) -> u32

How many of the diagnostics are errors. Greater than zero for every ParseError the parser produces — it fails only after reporting.

pub fn messages(&self) -> Vec<String>

The diagnostics rendered one string each, LLVM-style (location line, message, source line, caret), without ANSI colors.

Each string already ends with a newline — it is multi-line, and hermes_support::render::render_diagnostic terminates every line it writes. Print them with print!/eprint!; println! adds a blank line between diagnostics.

use hermes_parser::{parse, ParseFlags};

let err = parse("1 +", ParseFlags::default()).expect_err("bad parse");
for m in err.messages() {
    assert!(m.ends_with('\n'), "{m:?}");
    eprint!("{m}");
}

Examples found in repository

examples/parse_to_estree_json.rs (line 52)

fn main() {
    let path = std::env::args().nth(1);
    let (name, source) = match &path {
        Some(p) => (
            p.as_str(),
            std::fs::read_to_string(p).unwrap_or_else(|e| {
                eprintln!("cannot read '{p}': {e}");
                std::process::exit(1);
            }),
        ),
        None => (
            "<builtin>",
            "function greet(name) { return 'Hello, ' + name; }".to_string(),
        ),
    };

    // Plain ECMAScript. A file extension says nothing about the dialect, so
    // like `hermesc` this example assumes none; set the flags explicitly for
    // the others, e.g.:
    //     ParseFlags { parse_flow: true, ..Default::default() }   // Flow
    //     ParseFlags { parse_ts: true, ..Default::default() }     // TypeScript
    //     ParseFlags { parse_jsx: true, ..Default::default() }    // JSX
    let flags = ParseFlags::default();

    match parse_named(&source, name, flags) {
        Ok(mut parsed) => print!("{}", parsed.to_estree_json(true)),
        Err(e) => {
            // `Display` is the one-line summary; `messages()` is the full
            // LLVM-style rendering, which is what a CLI wants. Each string is
            // already newline-terminated, so this is `eprint!`, not
            // `eprintln!`.
            for m in e.messages() {
                eprint!("{m}");
            }
            std::process::exit(1);
        }
    }
}

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, f: &mut Formatter<'_>) -> Result

A single line — count plus the first error’s location and text — as error types are expected to produce. The full LLVM-style rendering (source line and caret) is messages; the structured form is diagnostics.

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.