refactor(parser): use diagnostics

Author: MilkeeyCat

src/compile.rs

@@ -46,15 +46,21 @@ pub fn compile(args: CompileArgs) -> Result<(), Box<dyn std::error::Error>> {
 
     file.read_to_string(&mut source_code)?;
 
-    let report_diag_and_exit = |diag: &Diagnostics| {
+    let report_diag_and_exit = |diag: &Diagnostics| -> ! {
         println!("{diag}");
 
-        std::process::exit(0x45);
+        std::process::exit(0x45)
     };
 
     let mut diagnostics = Diagnostics::new(&source_code);
     let lexer = Lexer::new(&source_code);
-    let ast = parser::Parser::new(lexer, &mut diagnostics)?.parse()?;
+    let ast = match parser::Parser::new(lexer, &mut diagnostics) {
+        Ok(mut parser) => match parser.parse() {
+            Ok(ast) => ast,
+            Err(_) => report_diag_and_exit(&diagnostics),
+        },
+        Err(_) => report_diag_and_exit(&diagnostics),
+    };
 
     if diagnostics.has_errors() {
         report_diag_and_exit(&mut diagnostics);

src/diagnostics.rs

@@ -1,10 +1,24 @@
-use crate::lexer::span::Span;
+use crate::lexer::{span::Span, TokenKind};
 use derive_more::derive::Display;
 
 #[derive(Debug, Display)]
 pub enum Diagnostic {
     #[display("syntax error: unknown character")]
     UnknownChar,
+    #[display("syntax error: expected {_0}")]
+    ParseExpected(String),
+    #[display("syntax error: {_0} is not a valid prefix operator")]
+    ExpressionPrefix(TokenKind),
+    #[display("syntax error: {_0} is not a valid infix operator")]
+    ExpressionInfix(TokenKind),
+    #[display("field `{_0}` is already declared")]
+    RepeatingField(String),
+    #[display("parameter `{_0}` is already declared")]
+    RepeatingParam(String),
+    #[display("integer literal is too large value exceeds limit of `{}`", u64::MAX)]
+    IntegerLitralTooLong,
+    #[display("function definition is not allowed here")]
+    IllegalFunctionDefinition,
 }
 
 #[derive(Debug, Eq, PartialEq, Display)]
@@ -70,7 +84,7 @@ impl<'src> Diagnostics<'src> {
     }
 
     fn lines(&self, span: &Span) -> usize {
-        self.source[span.end..span.start]
+        self.source[span.start..span.end]
             .chars()
             .filter(|ch| ch == &'\n')
             .count()