java-lang 0.3.2

A Java AST parser in Rust, syn-style API for Java 25 (JLS SE 25)
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

use std::fmt;

use crate::span::Span;

/// The error type for Java parsing.
#[derive(Debug, Clone)]
pub struct Error {
    message: String,
    span: Span,
}

impl Error {
    /// Create a new error with a message and span.
    pub fn new<T: fmt::Display>(span: Span, message: T) -> Self {
        Error {
            message: message.to_string(),
            span,
        }
    }

    /// Create an "expected token" error.
    pub(crate) fn expected_token(span: Span, expected: &str) -> Self {
        Error {
            message: format!("expected {}", expected),
            span,
        }
    }

    /// Get the span where the error occurred.
    pub fn span(&self) -> Span {
        self.span
    }

    /// Get the error message.
    pub fn message(&self) -> &str {
        &self.message
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let loc = self.span.start();
        write!(f, "error at byte offset {}: {}", loc, self.message)
    }
}

impl std::error::Error for Error {}

/// A specialized `Result` type for Java parsing.
pub type Result<T> = std::result::Result<T, Error>;