changed ast error behaviour

src/cli.rs

@@ -12,8 +12,8 @@ use notify::event::ModifyKind;
 use notify::EventKind::Modify;
 use notify::{Event, RecursiveMode, Watcher};
 
-use crate::compiler::ast::AstParserError;
 use crate::compiler::{FileCompilerSource, HexoCompiler, HexoCompilerContext};
+use crate::compiler::ast::Error;
 
 #[derive(Parser)]
 #[command(version, about, long_about = None)]
@@ -50,7 +50,7 @@ pub(crate) enum CliError {
     CantStartWatcher(notify::Error),
     CantCrateOutputFile(std::io::Error),
     CantReadInputFile(std::io::Error),
-    AstParsingFailed(AstParserError),
+    AstParsingFailed(Error),
     CompilationError(crate::compiler::CompilerError),
 }
 

src/compiler/ast/error.rs

@@ -0,0 +1,19 @@
+use std::fmt::Display;
+use crate::compiler::ast::parser::Rule;
+
+#[derive(Debug)]
+pub(crate) enum Error {
+    PestError(pest::error::Error<Rule>),
+    UnknownRule { rule_name: String },
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::PestError(e) => write!(f, "Parsing error: {}", e),
+            Error::UnknownRule { rule_name } => write!(f, "Unknown rule: {}", rule_name),
+        }
+    }
+}
+
+impl std::error::Error for Error {}

src/compiler/ast/mod.rs

@@ -1,5 +1,7 @@
 mod node;
 mod parser;
+mod error;
 
 pub(crate) use node::{AstNode, AstNodeType};
-pub(crate) use parser::{AstParser, AstParserError};
+pub(crate) use error::Error;
+pub(crate) use parser::AstParser;

src/compiler/ast/parser.rs

@@ -1,15 +1,10 @@
-use pest::error::Error;
+use std::fmt::Display;
 use pest::iterators::Pair;
 use pest::Parser;
 use pest_derive::Parser;
 
 use crate::compiler::ast::{AstNode, AstNodeType};
-
-#[derive(Debug)]
-pub(crate) enum AstParserError {
-    PestError(Error<Rule>),
-    UnknownRule { rule_name: String },
-}
+use crate::compiler::ast::error::Error;
 
 #[derive(Parser)]
 #[grammar = "grammar.pest"]
@@ -22,9 +17,9 @@ impl AstParser {
         AstParser {}
     }
 
-    pub(crate) fn parse(&self, source: String) -> Result<AstNode, AstParserError> {
+    pub(crate) fn parse(&self, source: String) -> Result<AstNode, Error> {
         let pairs = AstPestParser::parse(Rule::file, source.as_str())
-            .map_err(AstParserError::PestError)?;
+            .map_err(Error::PestError)?;
 
         let children: Result<Vec<AstNode>, _> = pairs
             .map(parse_ast_pair)
@@ -36,16 +31,16 @@ impl AstParser {
 }
 
 fn filter_ignored_token(
-    result: Result<Option<AstNode>, AstParserError>,
-) -> Option<Result<AstNode, AstParserError>> {
+    result: Result<Option<AstNode>, Error>,
+) -> Option<Result<AstNode, Error>> {
     match result {
         Ok(None) => None,
         Ok(Some(value)) => Some(Ok(value)),
         Err(error) => Some(Err(error)),
     }
 }
 
-fn parse_ast_pair(p: Pair<Rule>) -> Result<Option<AstNode>, AstParserError> {
+fn parse_ast_pair(p: Pair<Rule>) -> Result<Option<AstNode>, Error> {
     let node_type = match p.as_rule() {
         Rule::atom_utf8 => AstNodeType::AtomUtf8,
         Rule::atom_hex => AstNodeType::AtomHex,
@@ -72,7 +67,7 @@ fn parse_ast_pair(p: Pair<Rule>) -> Result<Option<AstNode>, AstParserError> {
 
         Rule::EOI => return Ok(None),
         _ => {
-            return Err(AstParserError::UnknownRule {
+            return Err(Error::UnknownRule {
                 rule_name: format!("{:?}", p.as_rule()),
             })
         }

src/compiler/compiler.rs

@@ -1,12 +1,12 @@
-use crate::compiler::ast::{AstNode, AstParser, AstParserError};
+use crate::compiler::ast::{AstNode, AstParser};
 use crate::compiler::cst::{CstFile, CstParser, CstParserError};
 use crate::compiler::rst::{HexoFile, RstCompiler, RstCompilerError};
 use crate::compiler::{Compilation, CompilerSource, HexoCompilerContext};
 
 #[derive(Debug)]
 pub(crate) enum CompilerError {
     IO(std::io::Error),
-    AST(AstParserError),
+    AST(crate::compiler::ast::Error),
     CST(CstParserError),
     RST(RstCompilerError),
 }