gosyn 0.2.9

Golang syntax parser in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

use crate::token::Token;
use crate::token::TokenKind;

use std::fmt::Display;
use std::fmt::{Debug, Formatter};
use std::io;
use std::path::PathBuf;

use thiserror::Error;

/// indicates all possible errors during parsing
#[derive(Error)]
pub enum Error {
    /// wrap system IO errors, usually an open error when opening the given path
    #[error(transparent)]
    IO(#[from] io::Error),
    /// syntax error such as some token are not in the right position
    UnexpectedToken {
        path: PathBuf,
        location: (usize, usize),
        expect: Vec<TokenKind>,
        actual: Option<Token>,
    },
    /// some other parser errors include scanner errors
    /// such as parsing numeric literal errors
    Else {
        path: PathBuf,
        location: (usize, usize),
        reason: String,
    },
}

impl Debug for Error {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::IO(err) => write!(f, "os error: {err}"),
            Error::UnexpectedToken { expect, actual, path, location } => {
                let (line, offset) = location;
                let path = format!("{:?}", path.as_os_str());
                let file_line = format!("{path:?}:{line}:{offset}");
                let exp = match expect.len() {
                    0 => "expected something".to_string(),
                    1 => format!("expected {:?}", expect[0]),
                    _ => format!("expected {expect:?}"),
                };

                match actual {
                    None => write!(f, "{file_line} {exp}, found EOF"),
                    Some(tok) => write!(f, "{file_line} {exp}, found {tok:?}"),
                }
            }
            Error::Else { path, location, reason } => {
                let (line, offset) = location;
                let path = format!("{:?}", path.as_os_str());
                write!(f, "{path:?}:{line}:{offset} {reason:?}")
            }
        }
    }
}

impl Display for Error {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}