add miette errors

Author: lucarlig

Cargo.toml

@@ -1,40 +1,27 @@
 [package]
 name = "descend"
-version = "0.1.0"
-authors = [
-    "Luca Carlig <[email protected]>",
-    "Köpcke <[email protected]>",
-]
-edition = "2021"
-
-# Allow specific lints globally
-[package.metadata.clippy]
-unused_variables = "allow"
-dead_code = "allow"
-unused_imports = "allow"
-unreachable_code = "allow"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
 
 [dependencies]
-clap = { version = "4.5", features = ["derive"] }
-insta = "1.43.2"
-melior = { version = "0.25", features = ["ods-dialects"] }
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies.peg]
-version = "0.8.0"
-
-[dependencies.annotate-snippets]
-version = "0.9.0"
-features = ["color"]
-
-[dependencies.descend_derive]
-path = "./descend_derive"
-
-[build-dependencies]
+clap = { version = "4.5.50", features = ["derive"] }
 melior = { version = "0.25", features = ["ods-dialects"] }
+miette = { version = "7.6.0", features = ["fancy", "syntect-highlighter"] }
+peg = "0.8.5"
+descend_derive = { path = "./descend_derive" }
 
 [dev-dependencies]
 insta = { version = "1.43.2", features = ["glob"] }
 
 [workspace]
 members = ["descend_derive"]
+resolver = "3"
+
+[workspace.package]
+version = "0.1.0"
+authors = [
+    "Luca Carlig <[email protected]>",
+    "Köpcke <[email protected]>",
+]
+edition = "2024"

descend_derive/Cargo.toml

@@ -1,18 +1,16 @@
 [package]
 name = "descend_derive"
-version = "0.1.0"
-authors = ["Köpcke <[email protected]>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
 
 [lib]
 proc-macro = true
 
 [build-dependencies]
 
 [dependencies]
-syn = { version = "1.0", features = ["full"] }
-quote = "1.0"
-proc-macro2 = "1.0"
-include_dir = "0.7"
+syn = { version = "2.0.108", features = ["full"] }
+quote = "1.0.41"
+proc-macro2 = "1.0.103"
+include_dir = "0.7.4"

descend_derive/src/lib.rs

@@ -46,7 +46,7 @@ pub fn span_derive(attr: TokenStream, input: TokenStream) -> TokenStream {
         std::mem::swap(&mut tmp, &mut field.attrs);
         tmp = tmp
             .into_iter()
-            .filter(|attr| !attr.path.is_ident(IGNORE_ATTR_NAME))
+            .filter(|attr| !attr.path().is_ident(IGNORE_ATTR_NAME))
             .collect::<Vec<_>>();
         std::mem::swap(&mut tmp, &mut field.attrs);
     }
@@ -64,7 +64,7 @@ pub fn span_derive(attr: TokenStream, input: TokenStream) -> TokenStream {
     for mut field in original_fields.named.clone().into_iter() {
         let mut ignored = false;
         for attr in field.attrs.iter() {
-            if attr.path.is_ident(IGNORE_ATTR_NAME) {
+            if attr.path().is_ident(IGNORE_ATTR_NAME) {
                 ignored = true;
                 break;
             }

src/error.rs

@@ -1,9 +1,10 @@
 use crate::parser::SourceCode;
-use annotate_snippets::display_list::{DisplayList, FormatOptions};
-use annotate_snippets::snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation};
+use miette::{Diagnostic, LabeledSpan};
 use std::fmt::Formatter;
 
 #[must_use]
+#[derive(Debug, Diagnostic)]
+#[diagnostic(severity(Error), code("file_io_error"))]
 pub struct FileIOError<'a> {
     file_path: &'a str,
     io_error: std::io::Error,
@@ -18,72 +19,45 @@ impl<'a> FileIOError<'a> {
     }
 
     pub fn emit(&self) -> ErrorReported {
-        println!("{}", self.to_string(self.file_path, &self.io_error));
+        eprintln!("couldn't read {}: {}", self.file_path, self.io_error);
         ErrorReported
     }
-
-    fn to_string(&self, path_to_file: &str, err: &std::io::Error) -> String {
-        let label = format!("couldn't read {}: {}", path_to_file, err);
-        let snippet = Snippet {
-            title: Some(Annotation {
-                id: None,
-                label: Some(&label),
-                annotation_type: AnnotationType::Error,
-            }),
-            footer: vec![],
-            slices: vec![],
-            opt: default_format(),
-        };
-        DisplayList::from(snippet).to_string()
-    }
 }
 
-impl std::fmt::Debug for FileIOError<'_> {
+impl<'a> std::fmt::Display for FileIOError<'a> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.io_error)
+        write!(f, "couldn't read {}: {}", self.file_path, self.io_error)
     }
 }
 
-pub fn default_format() -> FormatOptions {
-    FormatOptions {
-        color: true,
-        anonymized_line_numbers: false,
-        margin: None,
+impl<'a> std::error::Error for FileIOError<'a> {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&self.io_error)
     }
 }
 
 pub fn single_line_snippet<'a>(
     source: &'a SourceCode<'a>,
-    label: &'a str,
+    _label: &'a str,
     annotation: &'a str,
     line_num: u32,
     begin_column: u32,
     end_column: u32,
-) -> Snippet<'a> {
-    let slices = if let Some(line) = source.get_line(line_num) {
-        vec![Slice {
-            source: line,
-            line_start: line_num as usize + 1,
-            origin: source.file_path,
-            annotations: vec![SourceAnnotation {
-                range: (begin_column as usize, end_column as usize),
-                label: annotation,
-                annotation_type: AnnotationType::Error,
-            }],
-            fold: false,
-        }]
+) -> miette::Report {
+    if let Some(_line) = source.get_line(line_num) {
+        let start_offset = source.get_offset(line_num, begin_column);
+        let end_offset = source.get_offset(line_num, end_column);
+
+        miette::miette!(
+            labels = [LabeledSpan::new_with_span(
+                Some(annotation.to_string()),
+                start_offset..end_offset
+            )],
+            "{}",
+            annotation
+        )
     } else {
-        vec![]
-    };
-    Snippet {
-        title: Some(Annotation {
-            id: None,
-            label: Some(label),
-            annotation_type: AnnotationType::Error,
-        }),
-        footer: vec![],
-        slices,
-        opt: default_format(),
+        miette::miette!("{}", annotation)
     }
 }
 

src/parser/mod.rs

@@ -290,13 +290,13 @@ fn replace_struct_idents_with_specific_struct_dtys(struct_dtys: &[StructDecl], i
 pub mod error {
     use crate::error::ErrorReported;
     use crate::parser::{Parser, SourceCode};
-    use annotate_snippets::display_list::DisplayList;
-    use annotate_snippets::snippet::Snippet;
+    use miette::Diagnostic;
     use peg::error::ParseError as PegError;
     use peg::str::LineCol;
 
     #[must_use]
-    #[derive(Debug)]
+    #[derive(Debug, Diagnostic)]
+    #[diagnostic(severity(Error), code("parse_error"))]
     pub struct ParseError<'a> {
         parser: &'a Parser<'a>,
         err: PegError<LineCol>,
@@ -313,25 +313,33 @@ pub mod error {
                 u32::try_from(self.err.location.line).expect("Source file is unexpectedly large");
             let column_num =
                 u32::try_from(self.err.location.column).expect("Source file is unexpectedly large");
-            let snippet = single_line_parse_snippet(
+            let error = single_line_parse_snippet(
                 self.parser.source,
                 &label,
                 line_num,
                 column_num,
                 column_num + 1,
             );
-            println!("{}", DisplayList::from(snippet));
+            eprintln!("{}", error);
             ErrorReported
         }
     }
 
+    impl<'a> std::fmt::Display for ParseError<'a> {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "Parse error: expected {}", self.err.expected)
+        }
+    }
+
+    impl<'a> std::error::Error for ParseError<'a> {}
+
     fn single_line_parse_snippet<'a>(
         source: &'a SourceCode<'a>,
         label: &'a str,
         line_num: u32,
         begin_column: u32,
         end_column: u32,
-    ) -> Snippet<'a> {
+    ) -> miette::Report {
         // 1-based offsets to 0-based offsets
         crate::error::single_line_snippet(
             source,
@@ -1361,17 +1369,21 @@ mod tests {
             ))))),
             "does not recognize type of unique i32 reference in cpu heap with provenance 'a"
         );
-        assert_eq!(descend::ty("&b shrd npu.global [f32;N]"), Ok(Ty::new(TyKind::Data(Box::new(DataTy::new(DataTyKind::Ref(
-            Box::new(RefDty::new(
-                        Provenance::Ident(Ident::new("b")),
-                        Ownership::Shrd,
-                        Memory::NpuGm,
-                        DataTy::new(DataTyKind::Array(
-                            Box::new(DataTy::new(DataTyKind::Scalar(ScalarTy::F32))),
-                            Nat::Ident(Ident::new("N"))
-                        ))
-                    )))))),
-        )), "does not recognize type of shared [f32] reference in npu global memory with provenance b");
+        assert_eq!(
+            descend::ty("&b shrd npu.global [f32;N]"),
+            Ok(Ty::new(TyKind::Data(Box::new(DataTy::new(
+                DataTyKind::Ref(Box::new(RefDty::new(
+                    Provenance::Ident(Ident::new("b")),
+                    Ownership::Shrd,
+                    Memory::NpuGm,
+                    DataTy::new(DataTyKind::Array(
+                        Box::new(DataTy::new(DataTyKind::Scalar(ScalarTy::F32))),
+                        Nat::Ident(Ident::new("N"))
+                    ))
+                )))
+            ))),)),
+            "does not recognize type of shared [f32] reference in npu global memory with provenance b"
+        );
     }
 
     #[test]

src/parser/source.rs

@@ -63,6 +63,12 @@ impl<'a> SourceCode<'a> {
         }
     }
 
+    /// Get offset corresponding to line and column (both 0-based)
+    pub fn get_offset(&self, line_num: u32, col_num: u32) -> usize {
+        let line_offset = self.line_offsets[line_num as usize] as usize;
+        line_offset + col_num as usize
+    }
+
     /// Get line and column (both 0-based) corresponding to an offset in the
     /// source string
     pub fn get_line_col(&self, offset: u32) -> (u32, u32) {