Struct ResolveError 

pub struct ResolveError { /* private fields */ }

A resolution that reported at least one error.

There is no AST to carry, matching hermes_parser::ParseError: on the compile path there genuinely is none (the resolver returns nothing once it has failed), and on the parser path the tree is dropped rather than returned — use resolve_for_parser if you need the partially resolved tree that reported these errors.

Implementations

impl ResolveError

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

Every diagnostic recorded during parsing and resolution, in emission order.

pub fn error_count(&self) -> u32

How many of the diagnostics are errors. Greater than zero for every ResolveError the façade produces.

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, as hermes_parser::ParseError::messages does — print them with print!/eprint!, since println! adds a blank line between diagnostics.

Examples found in repository

examples/print_bindings.rs (line 157)

fn main() {
    let (name, source) = match std::env::args().nth(1) {
        Some(path) => match std::fs::read_to_string(&path) {
            Ok(s) => (path, s),
            Err(e) => {
                eprintln!("print_bindings: cannot read '{path}': {e}");
                std::process::exit(1);
            }
        },
        None => ("<builtin>".to_string(), SOURCE.to_string()),
    };

    // Step 1: parse. `ParseFlags::default()` is plain ECMAScript.
    let parsed = match parse_named(&source, &name, ParseFlags::default()) {
        Ok(parsed) => parsed,
        Err(e) => {
            // `messages()` strings are already newline-terminated.
            for m in e.messages() {
                eprint!("{m}");
            }
            std::process::exit(2);
        }
    };

    // Step 2: resolve. The compile path, so the standard globals exist and an
    // undeclared `console` comes back as `UndeclaredGlobalProperty` rather
    // than as nothing at all; `hermes_sema::resolve` is the parser path.
    let mut resolved =
        match resolve_for_compile(parsed, &CompileOptions::default()) {
            Ok(resolved) => resolved,
            Err(e) => {
                for m in e.messages() {
                    eprint!("{m}");
                }
                std::process::exit(2);
            }
        };

    // Step 3: walk. References into the arena die with the lock, so the
    // visitor collects owned `String`s and hands them back out.
    let rows = resolved.with_program(|gc, root, sem| {
        let mut printer = BindingPrinter {
            gc,
            sem,
            rows: Vec::new(),
        };
        printer.visit_node(root);
        printer.rows
    });

    println!("{}: {} identifiers", name, rows.len());
    for (name, role, binding) in rows {
        println!("  {name:<12} {role:<5} {binding}");
    }
}

examples/resolve_and_dump.rs (line 72)

fn main() -> ExitCode {
    let mut args = std::env::args().skip(1);
    let mut summary = false;
    let mut path = None;
    for arg in args.by_ref() {
        match arg.as_str() {
            "--summary" => summary = true,
            _ => path = Some(arg),
        }
    }
    let Some(path) = path else {
        eprintln!("usage: resolve_and_dump [--summary] <file.js>");
        return ExitCode::from(1);
    };

    let source = match std::fs::read_to_string(&path) {
        Ok(s) => s,
        Err(e) => {
            eprintln!("resolve_and_dump: cannot read '{path}': {e}");
            return ExitCode::from(1);
        }
    };

    // Step 1: parse. `ParseFlags::default()` is plain ECMAScript; set
    // `parse_flow`, `parse_ts` or `parse_jsx` for the other dialects.
    let parsed = match parse_named(&source, &path, ParseFlags::default()) {
        Ok(parsed) => parsed,
        Err(e) => {
            for m in e.messages() {
                eprint!("{m}");
            }
            return ExitCode::from(2);
        }
    };

    // Step 2: resolve. The compile path, with the standard globals declared —
    // what `hermesc -dump-sema` does. `hermes_sema::resolve` is the parser
    // path instead: no ambient declarations and no AST rewrites.
    let options = CompileOptions::default();
    let mut resolved = match resolve_for_compile(parsed, &options) {
        Ok(resolved) => resolved,
        Err(e) => {
            for m in e.messages() {
                eprint!("{m}");
            }
            return ExitCode::from(2);
        }
    };

    // Warnings, if any: resolution succeeded, so none of these is an error.
    for d in resolved.diagnostics() {
        eprintln!("{}:{}:{}: {}", d.file_name, d.line, d.col, d.message);
    }

    // Step 3: read the result.
    if summary {
        print_summary(&mut resolved);
    } else {
        // Bytes, not a `String`: an identifier can be an unpaired surrogate,
        // which the dumper writes as WTF-8.
        let dump = resolved.to_sema_dump();
        std::io::stdout().write_all(&dump).expect("write failed");
    }
    ExitCode::SUCCESS
}

Trait Implementations

impl Clone for ResolveError

fn clone(&self) -> ResolveError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolveError

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

Formats the value using the given formatter.

impl Display for ResolveError

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 ResolveError

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.