Struct ParseError 

pub struct ParseError {
    pub ty: ParseErrorType,
    pub token_index: usize,
    pub token_affinity: TokenAffinity,
    pub context: Option<ParseErrorContext>,
    /* private fields */
}

An error emitted while trying to parse a token list.

Each error has a type with more information, the token where the error occurred, and possibly some contextual information.

Fields

ty: ParseErrorType

The type of error.

token_index: usize

The index of the token where the error occurred.

token_affinity: TokenAffinity

Affinity of the token.

context: Option<ParseErrorContext>

Contextual information if available.

Implementations

impl ParseError

pub fn new( ty: ParseErrorType, token_index: usize, token_affinity: TokenAffinity, ) -> Self

Creates a new ParseError.

pub fn with_context( self, ty: ContextType, token_range: Range<usize>, end_affinity: TokenAffinity, ) -> Self

Attaches some context to the error.

pub fn replace_context( self, from_ty: ContextType, to_ty: ContextType, token_range: Range<usize>, end_affinity: TokenAffinity, ) -> Self

Replaces an existing context with a new one, if it matches.

pub fn display<'s>( &'s self, source: &'s str, tokens: &'s [TokenItem<'s>], file_name: Option<&'s str>, ) -> impl Display + 's

Returns an implementation of std::fmt::Display that pretty-prints the error and context using display_annotations.

Examples found in repository

examples/print_parser_error.rs (line 10)

fn main() {
    let source = include_str!("print_parser_error_script.nut");
    let tokens = tokenize(source, Flavor::SquirrelRespawn).unwrap();
    let parse_err = parse(&tokens).unwrap_err();

    println!(
        "{}",
        parse_err.display(source, &tokens, Some("print_parser_error_script.nut"))
    );
}

examples/print_ast.rs (line 19)

fn main() {
    let source = include_str!("print_ast_script.nut");

    let tokens = match tokenize(source, Flavor::SquirrelRespawn) {
        Ok(tokens) => tokens,
        Err(err) => {
            eprintln!("{}", err.display(source, Some("print_ast_script.nut")));
            return;
        }
    };

    let ast = match parse(&tokens) {
        Ok(ast) => ast,
        Err(err) => {
            eprintln!(
                "{}",
                err.display(source, &tokens, Some("print_ast_script.nut"))
            );
            return;
        }
    };

    println!("{ast:#?}");
}

examples/dryrun.rs (line 53)

fn main() {
    let mut args = std::env::args();
    let exe = args.next().unwrap();

    let base_path = match args.next() {
        Some(arg) => PathBuf::from(arg),
        None => {
            eprintln!("Usage: {exe} [path]");
            eprintln!();
            eprintln!("Provide a path to a file to parse that file, or a path to a directory to");
            eprintln!("recursively parse all .nut and .gnut files in the directory");
            std::process::exit(1);
        }
    };

    let mut total_size_bytes = 0;
    let mut total_lex_secs = 0.;
    let mut total_parse_secs = 0.;

    visit(&base_path, &mut |path| {
        let extension = path.extension().and_then(|val| val.to_str());
        if !matches!(extension, Some("nut") | Some("gnut")) {
            return;
        }

        println!("{}", path.display());

        let file_text = match std::fs::read_to_string(path) {
            Ok(text) => text,
            Err(err) => {
                println!("  could not read: {err}");
                return;
            }
        };

        let lex_start = Instant::now();
        let tokens = match tokenize(&file_text, Flavor::SquirrelRespawn) {
            Ok(tokens) => tokens,
            Err(err) => {
                eprintln!("{}", err.display(&file_text, path.to_str()));
                std::process::exit(1);
            }
        };
        let lex_secs = lex_start.elapsed().as_secs_f64();
        println!("  tokenize: {lex_secs}s");

        let parse_start = Instant::now();
        if let Err(err) = parse(&tokens) {
            eprintln!("{}", err.display(&file_text, &tokens, path.to_str()));
            std::process::exit(1);
        }
        let parse_secs = parse_start.elapsed().as_secs_f64();
        println!("  parse: {parse_secs}s");

        total_size_bytes += file_text.bytes().len();
        total_lex_secs += lex_secs;
        total_parse_secs += parse_secs;
    });

    let total_mb = total_size_bytes as f64 / 1048576.;
    println!("Finished!");
    println!(
        "Tokenize: {:.4}s, {:.2} MB/s",
        total_lex_secs,
        total_mb / total_lex_secs
    );
    println!(
        "Parse: {:.4}s, {:.2} MB/s",
        total_parse_secs,
        total_mb / total_parse_secs
    );
}

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.