AST & Parser

javac-rs-ast/src/ast.rs

@@ -0,0 +1,173 @@
+/// Java `boolean` type
+pub type Boolean = bool;
+/// Java `byte` type
+pub type Byte = i8;
+/// Java `short` type
+pub type Short = i16;
+/// Java `char` type
+pub type Char = u16;
+/// Java `int` type
+pub type Int = i32;
+/// Java `long` type
+pub type Long = i64;
+/// Java `float` type
+pub type Float = f32;
+/// Java `double` type
+pub type Double = f64;
+
+/// Type used for storing raw identifiers
+pub type IdentifierName = String;
+
+/// Type used for storing raw comment body
+pub type CommentBody = String;
+
+/// Type used for storing raw string literal body
+pub type StringLiteralValue = String;
+
+/// Java [literal](https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.10)
+#[derive(Debug, PartialEq)]
+pub enum Literal {
+    /// Literal of `int` type
+    Int(Int),
+    /// Literal of `long` type
+    Long(Long),
+    /// Literal of `float` type
+    Float(Float),
+    /// Literal of `double` type
+    Double(Double),
+    /// Literal of `boolean` type
+    Boolean(Boolean),
+    /// Literal of `char` type
+    Char(Char),
+    /// Literal of `java.lang.String` type
+    String(StringLiteralValue),
+    /// `null` literal
+    Null,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum Keyword {
+    //<editor-fold desc="List of keywords" defaultstate="collapsed">
+    Abstract,
+    Assert,
+    Boolean,
+    Break,
+    Byte,
+    Case,
+    Catch,
+    Char,
+    Class,
+    Const,
+    Continue,
+    Default,
+    Do,
+    Double,
+    Else,
+    Enum,
+    Extends,
+    Final,
+    Finally,
+    Float,
+    For,
+    Goto,
+    If,
+    Implements,
+    Import,
+    Instanceof,
+    Int,
+    Interface,
+    Long,
+    Native,
+    New,
+    Package,
+    Private,
+    Protected,
+    Public,
+    Return,
+    Short,
+    Static,
+    Strictfp,
+    Super,
+    Switch,
+    Synchronized,
+    This,
+    Throw,
+    Throws,
+    Transient,
+    Try,
+    Void,
+    Volatile,
+    While,
+    //</editor-fold>
+}
+
+impl Keyword {
+    /// Checks if this keyword represents a (primitive) type.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use javac_rs_ast::ast::Keyword;
+    ///
+    /// assert!(Keyword::Byte.is_type());
+    /// assert!(!Keyword::Private.is_type());
+    /// assert!(!Keyword::Synchronized.is_type());
+    /// ```
+    pub fn is_type(&self) -> bool {
+        matches!(
+            self,
+            Self::Boolean
+                | Self::Byte
+                | Self::Char
+                | Self::Double
+                | Self::Float
+                | Self::Int
+                | Self::Long
+                | Self::Short
+        )
+    }
+
+    /// Checks if this keyword represents an access modifier.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use javac_rs_ast::ast::Keyword;
+    ///
+    /// assert!(Keyword::Public.is_access_modifier());
+    /// assert!(!Keyword::Package.is_access_modifier());
+    /// assert!(!Keyword::Continue.is_access_modifier());
+    /// ```
+    pub fn is_access_modifier(&self) -> bool {
+        matches!(self, Self::Private | Self::Protected | Self::Public)
+    }
+
+    /// Checks if this keyword represents an unused keyword.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use javac_rs_ast::ast::Keyword;
+    ///
+    /// assert!(Keyword::Const.is_unused());
+    /// assert!(Keyword::Goto.is_unused());
+    /// assert!(!Keyword::Abstract.is_unused());
+    /// assert!(!Keyword::Case.is_unused());
+    /// ```
+    pub fn is_unused(&self) -> bool {
+        matches!(self, Self::Const | Self::Goto)
+    }
+}
+
+/// A Java expression in source code AST
+#[derive(Debug, PartialEq)]
+pub enum Expression {
+    /// Keyword expression
+    Keyword(Keyword),
+    /// Literal expression
+    Literal(Literal),
+    /// Identifier expression
+    Identifier(IdentifierName),
+    /// Comment expression
+    Comment(CommentBody),
+}

javac-rs-ast/src/lib.rs

@@ -1,10 +1,3 @@
 //! Elements of Java language AST (Abstract Syntax Tree)
 
-#[allow(clippy::panic)]
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}
+pub mod ast;

javac-rs-parser/Cargo.toml

@@ -5,4 +5,6 @@ authors = ["progrm_jarvis <[email protected]>"]
 edition = "2018"
 
 [dependencies]
+javac-rs-ast = { path = "../javac-rs-ast" }
 peg = "0.6.3"
+num-traits = "0.2.12"

javac-rs-parser/src/lib.rs

@@ -1,10 +1,5 @@
 //! Utilities for parsing Java language AST (Abstract Syntax Tree)
 
-#[allow(clippy::panic)]
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
-    }
-}
+mod parser;
+
+pub use parser::*;

javac-rs-parser/src/parser/literals.rs

@@ -0,0 +1,90 @@
+use num_traits::Num;
+use std::num::{ParseFloatError, ParseIntError};
+use std::str::FromStr;
+
+pub trait PrimitiveFrom<T> {
+    fn from(source: T) -> Self;
+}
+
+impl PrimitiveFrom<u32> for i32 {
+    fn from(source: u32) -> Self {
+        source as Self
+    }
+}
+
+impl PrimitiveFrom<u64> for i64 {
+    fn from(source: u64) -> Self {
+        source as Self
+    }
+}
+
+pub trait IntoStaticStr {
+    fn into_static_str(self) -> &'static str;
+}
+
+impl IntoStaticStr for ParseIntError {
+    fn into_static_str(self) -> &'static str {
+        "integer literal cannot be parsed"
+    }
+}
+
+impl IntoStaticStr for ParseFloatError {
+    fn into_static_str(self) -> &'static str {
+        "floating point literal cannot be parsed"
+    }
+}
+
+pub fn parse_integer_number<F: Num, T: Num + PrimitiveFrom<F>>(
+    digits: &str,
+    radix: u32,
+) -> Result<T, &'static str>
+where
+    <F as Num>::FromStrRadixErr: IntoStaticStr,
+{
+    F::from_str_radix(digits.replace('_', "").as_str(), radix)
+        .map(|value| T::from(value))
+        .map_err(|error| error.into_static_str())
+}
+
+pub fn parse_number_i32(digits: &str, radix: u32) -> Result<i32, &'static str> {
+    parse_integer_number::<u32, i32>(digits, radix)
+}
+
+pub fn parse_number_i64(digits: &str, radix: u32) -> Result<i64, &'static str> {
+    parse_integer_number::<u64, i64>(digits, radix)
+}
+
+pub fn parse_floating_point_number<T: FromStr>(digits: &str) -> Result<T, &'static str>
+where
+    T::Err: IntoStaticStr,
+{
+    digits
+        .replace('_', "")
+        .parse::<T>()
+        .map_err(|error| error.into_static_str())
+}
+
+pub fn parse_from_parts<T: FromStr>(
+    integer_digits: Option<&str>,
+    decimal_digits: Option<&str>,
+    exponent_digits: Option<&str>,
+    radix: u32,
+) -> Result<T, &'static str>
+where
+    T::Err: IntoStaticStr,
+{
+    format!(
+        "{}.{}e{}",
+        integer_digits
+            .map_or(Ok(0), |digits| i64::from_str_radix(digits, radix))
+            .map_err(|error| error.into_static_str())?,
+        decimal_digits
+            .map_or(Ok(0), |digits| i64::from_str_radix(digits, radix))
+            .map_err(|error| error.into_static_str())?,
+        exponent_digits
+            .map_or(Ok(0), |digits| i64::from_str_radix(digits, radix))
+            .map_err(|error| error.into_static_str())?
+    )
+    .parse::<T>()
+    .map_err(|error| error.into_static_str())
+}