change error system

Signed-off-by: squeakbug <[email protected]>

Author: squeakbug

Cargo.lock

@@ -18,6 +18,9 @@ regex = { path = "crates/regex" }
 rpds = { version = "1.1.0" }
 thiserror = { version = "2.0.11" }
 clap = { version = "4.5.31", features = ["derive"] }
+termcolor = { version = "1.4.1" }
+codespan-reporting = { version = "0.9.0" }
+camino = { version = "1.1.9" }
 
 [profile.release]
 lto = true

Cargo.toml

@@ -6,4 +6,7 @@ edition = "2021"
 
 [dependencies]
 thiserror = { workspace = true }
-lazy_static = { workspace = true }
+lazy_static = { workspace = true }
+termcolor = { workspace = true }
+codespan-reporting = { workspace = true }
+camino = { workspace = true }

crates/core/Cargo.toml

@@ -0,0 +1,140 @@
+use std::collections::HashMap;
+
+use camino::Utf8PathBuf;
+
+pub use codespan_reporting::diagnostic::{LabelStyle, Severity};
+use codespan_reporting::{diagnostic::Label as CodespanLabel, files::SimpleFiles};
+use termcolor::Buffer;
+
+use crate::lexer::SrcSpan;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Level {
+    Error,
+    Warning,
+}
+
+#[derive(Debug, Clone)]
+pub struct Label {
+    pub text: Option<String>,
+    pub span: SrcSpan,
+}
+
+impl Label {
+    fn to_codespan_label(&self, fileid: usize) -> CodespanLabel<usize> {
+        let label = CodespanLabel::new(
+            LabelStyle::Primary,
+            fileid,
+            (self.span.start as usize)..(self.span.end as usize),
+        );
+        match &self.text {
+            None => label,
+            Some(text) => label.with_message(text.clone()),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ExtraLabel {
+    pub src_info: Option<(String, Utf8PathBuf)>,
+    pub label: Label,
+}
+
+#[derive(Debug, Clone)]
+pub struct Location {
+    pub src: String,
+    pub path: Utf8PathBuf,
+    pub label: Label,
+    pub extra_labels: Vec<ExtraLabel>,
+}
+
+// TODO: split this into locationed diagnostics and locationless diagnostics
+#[derive(Debug, Clone)]
+pub struct Diagnostic {
+    pub title: String,
+    pub text: String,
+    pub level: Level,
+    pub location: Option<Location>,
+    pub hint: Option<String>,
+}
+
+impl Diagnostic {
+    pub fn write(&self, buffer: &mut Buffer) {
+        use std::io::Write;
+        match &self.location {
+            Some(location) => self.write_span(location, buffer),
+            None => self.write_title(buffer),
+        };
+
+        if !self.text.is_empty() {
+            writeln!(buffer, "{}", self.text).expect("write text");
+        }
+
+        if let Some(hint) = &self.hint {
+            writeln!(buffer, "Hint: {hint}").expect("write hint");
+        }
+    }
+
+    fn write_span(&self, location: &Location, buffer: &mut Buffer) {
+        let mut file_map = HashMap::new();
+        let mut files = SimpleFiles::new();
+
+        let main_location_path = location.path.as_str();
+        let main_location_src = location.src.as_str();
+        let main_file_id = files.add(main_location_path, main_location_src);
+        let _ = file_map.insert(main_location_path, main_file_id);
+
+        let mut labels = vec![location.label.to_codespan_label(main_file_id)];
+
+        location
+            .extra_labels
+            .iter()
+            .map(|l| {
+                let (location_src, location_path) = match &l.src_info {
+                    Some(info) => (info.0.as_str(), info.1.as_str()),
+                    _ => (main_location_src, main_location_path),
+                };
+                match file_map.get(location_path) {
+                    None => {
+                        let file_id = files.add(location_path, location_src);
+                        let _ = file_map.insert(location_path, file_id);
+                        l.label.to_codespan_label(file_id)
+                    }
+                    Some(i) => l.label.to_codespan_label(*i),
+                }
+            })
+            .for_each(|l| labels.push(l));
+
+        let severity = match self.level {
+            Level::Error => Severity::Error,
+            Level::Warning => Severity::Warning,
+        };
+
+        let diagnostic = codespan_reporting::diagnostic::Diagnostic::new(severity)
+            .with_message(&self.title)
+            .with_labels(labels);
+        let config = codespan_reporting::term::Config::default();
+        codespan_reporting::term::emit(buffer, &config, &files, &diagnostic)
+            .expect("write_diagnostic");
+    }
+
+    fn write_title(&self, buffer: &mut Buffer) {
+        use std::io::Write;
+        use termcolor::{Color, ColorSpec, WriteColor};
+        let (kind, colour) = match self.level {
+            Level::Error => ("error", Color::Red),
+            Level::Warning => ("warning", Color::Yellow),
+        };
+        buffer
+            .set_color(ColorSpec::new().set_bold(true).set_fg(Some(colour)))
+            .expect("write_title_color1");
+        write!(buffer, "{kind}").expect("write_title_kind");
+        buffer
+            .set_color(ColorSpec::new().set_bold(true))
+            .expect("write_title_color2");
+        write!(buffer, ": {}\n\n", self.title).expect("write_title_title");
+        buffer
+            .set_color(&ColorSpec::new())
+            .expect("write_title_reset");
+    }
+}

crates/core/src/diagnostic.rs

@@ -0,0 +1,122 @@
+use std::io::Write;
+
+use camino::Utf8PathBuf;
+use termcolor::Buffer;
+use thiserror::Error;
+
+use crate::{diagnostic::{Diagnostic, Label, Level, Location}, lexer::{self, SrcSpan}, parser::{ParserError, ParserErrorType}, sema::SemanticError};
+
+pub type Result<Ok, Err = Error> = std::result::Result<Ok, Err>;
+
+#[derive(Debug, Clone, Error)]
+pub enum Error {
+    #[error("failed to scan source code")]
+    Lexer{
+        path: Utf8PathBuf,
+        src: String,
+        error: lexer::LexerError,
+    },
+
+    #[error("failed to parse source code")]
+    Parser {
+        path: Utf8PathBuf,
+        src: String,
+        error: ParserError,
+    },
+
+    #[error("failed to resolve source code")]
+    Semantic {
+        path: Utf8PathBuf,
+        src: String,
+        error: SemanticError,
+    },
+}
+
+impl Error {
+    pub fn pretty_string(&self) -> String {
+        let mut nocolor = Buffer::no_color();
+        self.pretty(&mut nocolor);
+        String::from_utf8(nocolor.into_inner()).expect("Error printing produced invalid utf8")
+    }
+
+    pub fn pretty(&self, buffer: &mut Buffer) {
+        for diagnostic in self.to_diagnostics() {
+            diagnostic.write(buffer);
+            writeln!(buffer).expect("write new line after diagnostic");
+        }
+    }
+
+    pub fn to_diagnostics(&self) -> Vec<Diagnostic> {
+        match &self {
+            Error::Lexer { path, src, error } => {
+                let (label, extra) = error.details();
+                let text = extra.join("\n");
+
+                vec![Diagnostic {
+                    title: "Scanning error".into(),
+                    text,
+                    hint: None,
+                    level: Level::Error,
+                    location: Some(Location {
+                        label: Label {
+                            text: Some(label.to_string()),
+                            span: error.location.clone(),
+                        },
+                        path: path.clone(),
+                        src: src.clone(),
+                        extra_labels: vec![],
+                    }),
+                }]
+            },
+            Error::Parser { path, src, error } => {
+                let (label, extra) = error.details();
+                let text = extra.join("\n");
+
+                let adjusted_location = if error.kind == ParserErrorType::UnexpectedEof {
+                    SrcSpan {
+                        start: src.len() - 1,
+                        end: src.len() - 1,
+                    }
+                } else {
+                    error.location.clone()
+                };
+
+                vec![Diagnostic {
+                    title: "Parsing error".into(),
+                    text,
+                    hint: None,
+                    level: Level::Error,
+                    location: Some(Location {
+                        label: Label {
+                            text: Some(label.to_string()),
+                            span: adjusted_location,
+                        },
+                        path: path.clone(),
+                        src: src.clone(),
+                        extra_labels: vec![],
+                    }),
+                }]
+            },
+            Error::Semantic { path, src, error } => {
+                let (label, extra) = error.details();
+                let text = extra.join("\n");
+
+                vec![Diagnostic {
+                    title: "Semantic error".into(),
+                    text,
+                    hint: None,
+                    level: Level::Error,
+                    location: Some(Location {
+                        label: Label {
+                            text: Some(label.to_string()),
+                            span: error.location.clone(),
+                        },
+                        path: path.clone(),
+                        src: src.clone(),
+                        extra_labels: vec![],
+                    }),
+                }]
+            },
+        }
+    }
+}