chore: refactor project structure

Signed-off-by: azjezz <azjezz@protonmail.com>

Author: azjezz

bin/snapshot.rs

@@ -1,4 +1,4 @@
-use php_parser_rs::{Lexer, Parser};
+use php_parser_rs::prelude::{Lexer, Parser};
 use std::env;
 use std::fs::read_dir;
 use std::path::PathBuf;
@@ -41,7 +41,7 @@ fn main() {
         }
 
         let code = std::fs::read_to_string(&code_filename).unwrap();
-        let mut lexer = Lexer::new(None);
+        let mut lexer = Lexer::new();
         let tokens = lexer.tokenize(code.as_bytes());
 
         match tokens {

build.rs

@@ -81,7 +81,8 @@ fn build_success_test(entry: PathBuf, code_filename: PathBuf, ast_filename: Path
     format!(
         r#"#[test]
 fn test_success_{}() {{
-    use php_parser_rs::{{Lexer, Parser}};
+    use php_parser_rs::prelude::Parser;
+    use php_parser_rs::prelude::Lexer;
     use pretty_assertions::assert_str_eq;
 
     let code_filename = "{}";
@@ -90,7 +91,7 @@ fn test_success_{}() {{
     let code = std::fs::read_to_string(&code_filename).unwrap();
     let expected_ast = std::fs::read_to_string(&ast_filename).unwrap();
 
-    let mut lexer = Lexer::new(None);
+    let mut lexer = Lexer::new();
     let tokens = lexer.tokenize(code.as_bytes()).unwrap();
     let mut parser = Parser::new(None);
     let ast = parser.parse(tokens).unwrap();
@@ -113,7 +114,7 @@ fn build_lexer_error_test(
     format!(
         r#"#[test]
 fn test_lexer_error_{}() {{
-    use php_parser_rs::Lexer;
+    use php_parser_rs::prelude::Lexer;
     use pretty_assertions::assert_str_eq;
 
     let code_filename = "{}";
@@ -122,7 +123,7 @@ fn test_lexer_error_{}() {{
     let code = std::fs::read_to_string(&code_filename).unwrap();
     let expected_error = std::fs::read_to_string(&lexer_error_filename).unwrap();
 
-    let mut lexer = Lexer::new(None);
+    let mut lexer = Lexer::new();
     let error = lexer.tokenize(code.as_bytes()).err().unwrap();
 
     assert_str_eq!(expected_error.trim(), format!("{{:?}}", error));
@@ -143,7 +144,8 @@ fn build_parser_error_test(
     format!(
         r#"#[test]
 fn test_paser_error_{}() {{
-    use php_parser_rs::{{Lexer, Parser}};
+    use php_parser_rs::prelude::Parser;
+    use php_parser_rs::prelude::Lexer;
     use pretty_assertions::assert_str_eq;
 
     let code_filename = "{}";
@@ -152,7 +154,7 @@ fn test_paser_error_{}() {{
     let code = std::fs::read_to_string(&code_filename).unwrap();
     let expected_error = std::fs::read_to_string(&parser_error_filename).unwrap();
 
-    let mut lexer = Lexer::new(None);
+    let mut lexer = Lexer::new();
     let tokens = lexer.tokenize(code.as_bytes()).unwrap();
 
     let mut parser = Parser::new(None);

src/ast.rs

@@ -1,6 +1,7 @@
 use std::fmt::Display;
 
-use crate::{ByteString, TokenKind};
+use crate::lexer::byte_string::ByteString;
+use crate::lexer::token::TokenKind;
 
 pub type Block = Vec<Statement>;
 pub type Program = Block;
@@ -103,18 +104,6 @@ impl From<&ByteString> for Identifier {
     }
 }
 
-impl From<&[u8]> for Identifier {
-    fn from(name: &[u8]) -> Self {
-        Self::from(ByteString::from(name))
-    }
-}
-
-impl From<&str> for Identifier {
-    fn from(name: &str) -> Self {
-        Self::from(ByteString::from(name))
-    }
-}
-
 pub type ParamList = Vec<Param>;
 
 #[derive(Debug, PartialEq, Clone)]

src/lexer/error.rs

@@ -0,0 +1,58 @@
+use std::fmt::Display;
+
+use crate::lexer::token::Span;
+
+pub type LexResult<T> = Result<T, SyntaxError>;
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum SyntaxError {
+    UnexpectedEndOfFile(Span),
+    UnexpectedError(Span),
+    UnexpectedCharacter(u8, Span),
+    InvalidHaltCompiler(Span),
+    InvalidOctalEscape(Span),
+    InvalidOctalLiteral(Span),
+    InvalidUnicodeEscape(Span),
+}
+
+impl Display for SyntaxError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::UnexpectedEndOfFile(span) => write!(
+                f,
+                "Syntax Error: unexpected end of file on line {} column {}",
+                span.0, span.1
+            ),
+            Self::UnexpectedError(span) => write!(
+                f,
+                "Syntax Error: unexpected error on line {} column {}",
+                span.0, span.1
+            ),
+            Self::UnexpectedCharacter(char, span) => write!(
+                f,
+                "Syntax Error: unexpected character `{:?}` on line {} column {}",
+                *char as char, span.0, span.1
+            ),
+            Self::InvalidHaltCompiler(span) => write!(
+                f,
+                "Syntax Error: invalid halt compiler on line {} column {}",
+                span.0, span.1
+            ),
+            Self::InvalidOctalEscape(span) => write!(
+                f,
+                "Syntax Error: invalid octal escape on line {} column {}",
+                span.0, span.1
+            ),
+            Self::InvalidOctalLiteral(span) => write!(
+                f,
+                "Syntax Error: invalid octal literal on line {} column {}",
+                span.0, span.1
+            ),
+            Self::InvalidUnicodeEscape(span) => write!(
+                f,
+                "Syntax Error: invalid unicode escape on line {} column {}",
+                span.0, span.1
+            ),
+        }
+    }
+}