Merge pull request #42 from gt-cs2110/updates-4.3.0

LC3Tools v4.2.6

Author: endorpersand

src/backend/Cargo.lock

@@ -2,16 +2,17 @@
 name = "lc3-backend"
 version = "0.1.0"
 license = "MIT"
-edition = "2021"
+edition = "2024"
 exclude = ["index.node"]
-rust-version = "1.80"
+rust-version = "1.85"
 
 [lib]
 crate-type = ["cdylib"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-ariadne = "0.5.0"
-lc3-ensemble = "0.9.2"
+lc3-ensemble = "0.10.0"
+miette = { version = "7.6.0", features = ["fancy"] }
 neon = "1"
+owo-colors = "4.2.0"

src/backend/Cargo.toml

@@ -1,134 +1,188 @@
 use std::borrow::Cow;
 use std::convert::Infallible;
 use std::path::Path;
+use std::sync::LazyLock;
 
-use ariadne::{ColorGenerator, Label, Report, ReportKind, Source};
 use lc3_ensemble::err::ErrSpan;
+use miette::highlighters::{Highlighter, HighlighterState};
+use miette::{Diagnostic, GraphicalReportHandler, GraphicalTheme, NamedSource, Severity, ThemeCharacters, ThemeStyles};
 use neon::context::Context;
 use neon::result::Throw;
+use owo_colors::style;
 
-pub(crate) fn simple_reporter<E: std::fmt::Display + ?Sized>(err: &E) -> Reporter<'_, E> {
-    Reporter {
-        err,
-        filename: None,
-        source: None,
-        span: None,
-        help: None,
-        msg_includes_fname: true
+struct FlatHighlighter(owo_colors::Style);
+impl Highlighter for FlatHighlighter {
+    fn start_highlighter_state<'h>(
+        &'h self,
+        _: &dyn miette::SpanContents<'_>,
+    ) -> Box<dyn HighlighterState + 'h> {
+        struct Highlighted(owo_colors::Style);
+        impl HighlighterState for Highlighted {
+            fn highlight_line<'s>(&mut self, line: &'s str) -> Vec<owo_colors::Styled<&'s str>> {
+                vec![self.0.style(line)]
+            }
+        }
+
+        Box::new(Highlighted(self.0))
     }
 }
+static REPORT_HANDLER: LazyLock<GraphicalReportHandler> = LazyLock::new(|| {
+    let style_dimmed = style().fg_rgb::<0xA0, 0xA0, 0xA0>();
+
+    GraphicalReportHandler::new_themed(GraphicalTheme {
+        characters: ThemeCharacters {
+            error: String::from("Error:"),
+            warning: String::from("Warning:"),
+            advice: String::from("Info:"),
+            ..ThemeCharacters::unicode()
+        },
+        styles: ThemeStyles {
+            link: style(),
+            linum: style_dimmed,
+            highlights: vec![
+                style().magenta(),
+                style().yellow(),
+                style().green(),
+            ],
+            ..ThemeStyles::ansi()
+        }
+    })
+    .with_context_lines(1)
+    .with_syntax_highlighting(FlatHighlighter(style_dimmed)) // Make code gray
+});
 
-pub(crate) fn io_reporter<'a, E: std::fmt::Display + ?Sized>(err: &'a E, fp: &'a Path) -> Reporter<'a, E> {
-    Reporter {
-        err,
-        filename: fp.file_name().and_then(|s| s.to_str()),
-        source: None,
-        span: None,
-        help: None,
-        msg_includes_fname: true
+#[derive(Debug)]
+enum ReporterSource<'s> {
+    Unlabeled(&'s str),
+    Labeled(NamedSource<String>)
+}
+impl<'s> ReporterSource<'s> {
+    fn new<'a>(filename: Option<&'a str>, source: &'s str) -> Self {
+        match filename {
+            Some(name) => ReporterSource::Labeled(NamedSource::new(name, source.to_string())),
+            None => ReporterSource::Unlabeled(source),
+        }
     }
 }
-pub(crate) fn error_reporter<'a, E: lc3_ensemble::err::Error + ?Sized>(err: &'a E, fp: &'a Path, src: &'a str) -> Reporter<'a, E> {
-    let span = err.span();
-    let help = err.help();
-
-    Reporter {
-        err,
-        filename: fp.file_name().and_then(|s| s.to_str()),
-        source: Some(Source::from(src.to_string())),
-        span,
-        help,
-        msg_includes_fname: false,
+impl miette::SourceCode for ReporterSource<'_> {
+    fn read_span<'a>(
+        &'a self,
+        span: &miette::SourceSpan,
+        context_lines_before: usize,
+        context_lines_after: usize,
+    ) -> Result<Box<dyn miette::SpanContents<'a> + 'a>, miette::MietteError> {
+        match self {
+            ReporterSource::Unlabeled(s) => s.read_span(span, context_lines_before, context_lines_after),
+            ReporterSource::Labeled(s) => s.read_span(span, context_lines_before, context_lines_after),
+        }
     }
 }
 
-pub(crate) struct Reporter<'c, E: ?Sized> {
-    err: &'c E,
-    filename: Option<&'c str>,
-    source: Option<Source<String>>,
+pub(crate) struct Reporter<'r, E: std::fmt::Display + ?Sized> {
+    /// Error (and message to print)
+    err: &'r E,
+    /// The filename of file where this error occurred (if there is a file)
+    filename: Option<&'r str>,
+    /// Source code
+    source: Option<ReporterSource<'r>>,
+    /// Span where error occurred
     span: Option<ErrSpan>,
-    help: Option<Cow<'c, str>>,
-    msg_includes_fname: bool
+    /// Relevant help messages
+    help: Option<Cow<'r, str>>,
+    /// Whether to include the filename in the error message
+    /// (can be false if it'd already appear elsewhere)
+    include_name_in_msg: bool
 }
+impl<E: std::fmt::Display + ?Sized> std::fmt::Debug for Reporter<'_, E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Reporter")
+            .field("err", &self.err.to_string())
+            .field("filename", &self.filename)
+            .field("source", &self.source)
+            .field("span", &self.span)
+            .field("help", &self.help)
+            .field("include_name_in_msg", &self.include_name_in_msg)
+            .finish()
+    }
+}
+impl<E: std::fmt::Display + ?Sized> std::fmt::Display for Reporter<'_, E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.filename {
+            Some(filename) if self.include_name_in_msg => write!(f, "{filename}: {}", self.err),
+            _ => write!(f, "{}", self.err),
+        }
+    }
+}
+impl<E: std::fmt::Display + ?Sized> std::error::Error for Reporter<'_, E> {}
+impl<E: std::fmt::Display + ?Sized> Diagnostic for Reporter<'_, E> {
+    fn severity(&self) -> Option<Severity> {
+        Some(Severity::Error)
+    }
 
-impl<E: std::fmt::Display + ?Sized> Reporter<'_, E> {
-    pub(crate) fn report(&mut self, writer: &mut impl std::io::Write) {
-        let mut colors = ColorGenerator::new();
-
-        let msg = if self.msg_includes_fname {
-            if let Some(fname) = self.filename {
-                format!("{}: {}", fname, self.err)
-            } else {
-                self.err.to_string()
-            }
-        } else {
-            self.err.to_string()
-        };
-        let fname = self.filename.unwrap_or("source");
-        let span = self.span.as_ref().map_or(0..0, |s| s.first());
-        
-        let mut report = Report::build(ReportKind::Error, (fname, span)).with_message(msg);
-        match self.span.clone() {
-            Some(ErrSpan::One(r)) => {
-                report.add_label({
-                    let mut label = Label::new((fname, r))
-                        .with_color(colors.next());
-                    
-                    if let Some(help) = self.help.as_deref() {
-                        label = label.with_message(help);
-                    }
+    fn help<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        self.help.as_ref().filter(|s| !s.is_empty()).map(|s| Box::new(s) as _)
+    }
 
-                    label
-                })
-            },
-            Some(ErrSpan::Two([r0, r1])) => {
-                report.add_label({
-                    Label::new((fname, r0))
-                            .with_color(colors.next())
-                            .with_message("")
-                });
-                report.add_label({
-                    Label::new((fname, r1))
-                            .with_color(colors.next())
-                            .with_message("")
-                });
+    fn source_code(&self) -> Option<&dyn miette::SourceCode> {
+        self.source.as_ref().map(|s| s as &dyn miette::SourceCode)
+    }
 
-                if let Some(help) = self.help.as_deref() {
-                    report.set_help(help);
-                }
-            },
-            Some(ErrSpan::Many(mr)) => {
-                report.add_labels({
-                    mr.into_iter()
-                        .map(|s| {
-                            Label::new((fname, s.clone()))
-                                .with_color(colors.next())
-                                .with_message("")
-                        })
-                });
+    fn labels(&self) -> Option<Box<dyn Iterator<Item = miette::LabeledSpan> + '_>> {
+        self.span.as_ref().map(|s| Box::new(
+            s.iter().map(|s| miette::LabeledSpan::new_with_span(None, s.clone()))
+        ) as _)
+    }
+}
 
-                if let Some(help) = self.help.as_deref() {
-                    report.set_help(help);
-                }
-            },
-            None => {
-                if let Some(help) = self.help.as_deref() {
-                    report.add_label(Label::new((fname, 0..0)));
-                    report.set_help(help);
-                };
-            }
+impl<'r, E: std::fmt::Display + ?Sized> Reporter<'r, E> {
+    pub(crate) fn simple(err: &'r E) -> Self {
+        Reporter {
+            err,
+            filename: None,
+            source: None,
+            span: None,
+            help: None,
+            include_name_in_msg: true
+        }
+    }
+    
+    pub(crate) fn io(err: &'r E, fp: &'r Path) -> Self {
+        Reporter {
+            err,
+            filename: fp.file_name().and_then(|s| s.to_str()),
+            source: None,
+            span: None,
+            help: None,
+            include_name_in_msg: true
+        }
+    }
+    pub(crate) fn ensemble(err: &'r E, fp: &'r Path, src: &'r str) -> Self
+        where E: lc3_ensemble::err::Error
+    {
+        let span = err.span();
+        let help = err.help();
+        let filename = fp.file_name().and_then(|s| s.to_str());
+        Reporter {
+            err,
+            filename,
+            source: Some(ReporterSource::new(filename, src)),
+            span,
+            help,
+            include_name_in_msg: false,
         }
-        
-        let source = match &self.source {
-            Some(s) => s.clone(),
-            None    => Source::from(String::new()),
-        };
-        report.finish()
-            .write((fname, source), writer)
-            .unwrap();
+    }
+}
+
+impl<E: std::fmt::Display + ?Sized> Reporter<'_, E> {
+    pub(crate) fn report(&mut self, writer: &mut Vec<u8>) {
+        let mut report = String::new();
+        REPORT_HANDLER.render_report(&mut report, self).unwrap();
+
+        // Remove whitespace that miette adds at the beginning of reports
+        writer.extend(report.trim_start().as_bytes());
     }
 
-    pub(crate) fn report_and_throw<'a>(mut self, writer: &mut impl std::io::Write, cx: &mut impl Context<'a>) -> Throw {
+    pub(crate) fn report_and_throw<'a>(mut self, writer: &mut Vec<u8>, cx: &mut impl Context<'a>) -> Throw {
         self.report(writer);
 
         cx.throw_error::<_, Infallible>(self.err.to_string())