more ergonomic receive function of handler

Cargo.toml

@@ -30,7 +30,7 @@ getset = "0.1.2"
 mlua = { version = "0.9.7", features = ["lua54", "vendored"], optional = true }
 path-absolutize = "3.1.1"
 serde = { version = "1.0.197", features = ["derive", "rc"], optional = true }
-shulkerbox = { git = "https://github.com/moritz-hoelting/shulkerbox", default-features = false, optional = true, rev = "e31f9f904a5f5905e912907d988c189ffc8cf313" }
+shulkerbox = { git = "https://github.com/moritz-hoelting/shulkerbox", default-features = false, optional = true, rev = "7efe73eb80fb66d3d9eb67eeb7bcb10727462956" }
 strum = { version = "0.26.2", features = ["derive"] }
 strum_macros = "0.26.2"
 thiserror = "1.0.58"

src/base/diagnostic.rs

@@ -1,7 +1,9 @@
 /// Represents a trait responsible for handling diagnostics in the interpreter.
 pub trait Handler<T> {
     /// Receive an error and handles it.
-    fn receive(&self, error: T);
+    fn receive<E: Into<T>>(&self, error: E);
+    /// Returns whether the handler has received any error.
+    fn has_received(&self) -> bool;
 }
 
 /// Is a struct that implements [`Handler`] trait by doing nothing with the errors.
@@ -9,5 +11,8 @@ pub trait Handler<T> {
 pub struct DummyHandler;
 
 impl<T> Handler<T> for DummyHandler {
-    fn receive(&self, _error: T) {}
+    fn receive<E: Into<T>>(&self, _error: E) {}
+    fn has_received(&self) -> bool {
+        false
+    }
 }

src/lexical/token.rs

@@ -492,12 +492,9 @@ impl Token {
                 }
                 .into())
             } else {
-                handler.receive(
+                handler.receive(UnterminatedDelimitedComment {
-                    UnterminatedDelimitedComment {
                     span: Span::new(iter.source_file().clone(), start, start + 2).unwrap(),
-                    }
+                });
-                    .into(),
-                );
                 return Err(TokenizeError::FatalLexicalError);
             }
         }

src/lexical/token_stream.rs

@@ -92,7 +92,7 @@ impl TokenStream {
     fn handle_popped_token(
         tokens: &mut Vec<Token>,
         popped_token: Token,
-        handler: &dyn Handler<error::Error>,
+        handler: &impl Handler<error::Error>,
     ) -> Option<TokenTree> {
         match popped_token {
             Token::Punctuation(punc) if punc.punctuation == '{' => {
@@ -116,7 +116,7 @@ impl TokenStream {
         tokens: &mut Vec<Token>,
         open: Punctuation,
         delimiter: Delimiter,
-        handler: &dyn Handler<error::Error>,
+        handler: &impl Handler<error::Error>,
     ) -> Option<Delimited> {
         let mut token_trees = Vec::new();
 

src/lib.rs

@@ -107,9 +107,13 @@ impl Printer {
     }
 }
 
-impl<E: Display> Handler<E> for Printer {
+impl<T: Display> Handler<T> for Printer {
-    fn receive(&self, error: E) {
+    fn receive<E: Into<T>>(&self, error: E) {
-        eprintln!("{error}");
+        eprintln!("{}", error.into());
         self.printed.set(true);
     }
+
+    fn has_received(&self) -> bool {
+        self.printed.get()
+    }
 }

src/syntax/parser.rs

@@ -42,7 +42,7 @@ impl<'a> Parser<'a> {
         &mut self,
         delimiter: Delimiter,
         f: impl FnOnce(&mut Self) -> Option<T>,
-        handler: &dyn Handler<Error>,
+        handler: &impl Handler<Error>,
     ) -> Option<DelimitedTree<T>> {
         self.current_frame.stop_at_significant();
         let raw_token_tree = self

src/syntax/syntax_tree/program.rs

@@ -102,13 +102,10 @@ impl<'a> Parser<'a> {
                 })
             }
             unexpected => {
-                handler.receive(
+                handler.receive(UnexpectedSyntax {
-                    UnexpectedSyntax {
                     expected: SyntaxKind::Keyword(KeywordKind::Namespace),
                     found: unexpected.into_token(),
-                    }
+                });
-                    .into(),
-                );
                 None
             }
         }?;

src/syntax/syntax_tree/statement/execute_block.rs

@@ -775,13 +775,10 @@ impl<'a> Parser<'a> {
                         handler,
                     ),
                     unexpected => {
-                        handler.receive(
+                        handler.receive(UnexpectedSyntax {
-                            UnexpectedSyntax {
                             expected: SyntaxKind::Punctuation('('),
                             found: unexpected.into_token(),
-                            }
+                        });
-                            .into(),
-                        );
                         None
                     }
                 }?;
@@ -795,13 +792,10 @@ impl<'a> Parser<'a> {
 
             // unexpected
             unexpected => {
-                handler.receive(
+                handler.receive(UnexpectedSyntax {
-                    UnexpectedSyntax {
                     expected: SyntaxKind::ExecuteBlock,
                     found: unexpected.into_token(),
-                    }
+                });
-                    .into(),
-                );
                 None
             }
         }
@@ -833,13 +827,10 @@ impl<'a> Parser<'a> {
             }
 
             unexpected => {
-                handler.receive(
+                handler.receive(UnexpectedSyntax {
-                    UnexpectedSyntax {
                     expected: SyntaxKind::ExecuteBlockTail,
                     found: unexpected.into_token(),
-                    }
+                });
-                    .into(),
-                );
                 None
             }
         }