Introduce Diagnostic type and remove ariadne from public API

crates/codegen/runtime/cargo/Cargo.toml

@@ -12,7 +12,7 @@ anyhow = { workspace = true }
 codegen_runtime_generator = { workspace = true }
 
 [dependencies]
-ariadne = { workspace = true }
+ariadne = { workspace = true, optional = true }
 napi = { workspace = true, optional = true }
 napi-derive = { workspace = true, optional = true }
 nom = { workspace = true }
@@ -28,6 +28,8 @@ thiserror = { workspace = true }
 [features]
 default = ["slang_napi_interfaces"]
 slang_napi_interfaces = ["dep:napi", "dep:napi-derive", "dep:serde_json"]
+# Only used by the `slang_solidity` CLI
+__private_ariadne = ["dep:ariadne"]
 
 [lints]
 workspace = true

crates/codegen/runtime/cargo/src/runtime/diagnostic.rs

@@ -0,0 +1,65 @@
+use std::borrow::Cow;
+use std::error::Error;
+
+use crate::text_index::TextRange;
+
+#[repr(u8)]
+pub enum Severity {
+    Error = 1,
+    Warning = 2,
+    Information = 3,
+    Hint = 4,
+}
+
+pub trait Diagnostic: Error {
+    fn range(&self) -> TextRange;
+    fn code(&self) -> Option<Cow<'_, str>> {
+        None
+    }
+    fn severity(&self) -> Severity;
+    fn message(&self) -> String;
+}
+
+#[cfg(feature = "__private_ariadne")]
+pub fn render<D: Diagnostic>(error: &D, source_id: &str, source: &str, with_color: bool) -> String {
+    use ariadne::{Color, Config, Label, Report, ReportKind, Source};
+
+    use crate::text_index::TextRangeExtensions as _;
+
+    let kind = match error.severity() {
+        Severity::Error => ReportKind::Error,
+        Severity::Warning => ReportKind::Warning,
+        Severity::Information => ReportKind::Advice,
+        Severity::Hint => ReportKind::Advice,
+    };
+
+    let color = if with_color { Color::Red } else { Color::Unset };
+
+    let message = error.message();
+
+    if source.is_empty() {
+        return format!("{kind}: {message}\n   ─[{source_id}:0:0]");
+    }
+
+    let range = error.range().char();
+
+    let report = Report::build(kind, source_id, range.start)
+        .with_config(Config::default().with_color(with_color))
+        .with_message(message)
+        .with_label(
+            Label::new((source_id, range))
+                .with_color(color)
+                .with_message("Error occurred here."),
+        )
+        .finish();
+
+    let mut result = vec![];
+    report
+        .write((source_id, Source::from(&source)), &mut result)
+        .expect("Failed to write report");
+
+    return String::from_utf8(result)
+        .expect("Failed to convert report to utf8")
+        .trim()
+        .to_string();
+}

crates/codegen/runtime/cargo/src/runtime/mod.rs

@@ -4,6 +4,7 @@ pub(crate) mod lexer;
 
 pub mod cst;
 pub mod cursor;
+pub mod diagnostic;
 pub mod parse_error;
 pub mod parse_output;
 pub mod query;

crates/codegen/runtime/cargo/src/runtime/napi_interface/cst.rs

@@ -63,7 +63,7 @@ impl RuleNode {
         catch_unwind
     )]
     pub fn text_len(&self) -> TextIndex {
-        (&self.0.text_len).into()
+        self.0.text_len.into()
     }
 
     #[napi(ts_return_type = "Array<cst.Node>", catch_unwind)]
@@ -81,7 +81,7 @@ impl RuleNode {
         #[napi(ts_arg_type = "text_index.TextIndex")] text_offset: TextIndex,
     ) -> Cursor {
         RustNode::Rule(Rc::clone(&self.0))
-            .cursor_with_offset((&text_offset).into())
+            .cursor_with_offset(text_offset.into())
             .into()
     }
 
@@ -151,7 +151,7 @@ impl TokenNode {
     )]
     pub fn text_len(&self) -> TextIndex {
         let text_len: RustTextIndex = (&self.0.text).into();
-        (&text_len).into()
+        text_len.into()
     }
 
     #[napi(getter, catch_unwind)]
@@ -173,7 +173,7 @@ impl TokenNode {
         #[napi(ts_arg_type = "text_index.TextIndex")] text_offset: TextIndex,
     ) -> Cursor {
         RustNode::Token(Rc::clone(&self.0))
-            .cursor_with_offset((&text_offset).into())
+            .cursor_with_offset(text_offset.into())
             .into()
     }
 }

crates/codegen/runtime/cargo/src/runtime/napi_interface/cursor.rs

@@ -63,12 +63,12 @@ impl Cursor {
 
     #[napi(getter, ts_return_type = "text_index.TextIndex", catch_unwind)]
     pub fn text_offset(&self) -> TextIndex {
-        (&self.0.text_offset()).into()
+        self.0.text_offset().into()
     }
 
     #[napi(getter, ts_return_type = "text_index.TextRange", catch_unwind)]
     pub fn text_range(&self) -> TextRange {
-        (&self.0.text_range()).into()
+        self.0.text_range().into()
     }
 
     #[allow(clippy::cast_possible_truncation)] // Cursor depth can't reasonably be larger than u32

crates/codegen/runtime/cargo/src/runtime/napi_interface/diagnostic.rs

@@ -0,0 +1,51 @@
+use napi_derive::napi;
+
+use crate::napi_interface::text_index::TextRange;
+
+/// Severity of the compiler diagnostic.
+///
+/// Explicitly compatible with the LSP protocol.
+#[napi(namespace = "diagnostic")]
+pub enum Severity {
+    Error = 1,
+    Warning = 2,
+    Information = 3,
+    Hint = 4,
+}
+
+impl From<crate::diagnostic::Severity> for Severity {
+    fn from(value: crate::diagnostic::Severity) -> Severity {
+        match value {
+            crate::diagnostic::Severity::Error => Self::Error,
+            crate::diagnostic::Severity::Warning => Self::Warning,
+            crate::diagnostic::Severity::Information => Self::Information,
+            crate::diagnostic::Severity::Hint => Self::Hint,
+        }
+    }
+}
+
+#[napi(namespace = "diagnostic")]
+pub struct Diagnostic(pub(crate) Box<dyn crate::diagnostic::Diagnostic>);
+
+#[napi(namespace = "diagnostic")]
+impl Diagnostic {
+    #[napi]
+    pub fn severity(&self) -> Severity {
+        self.0.severity().into()
+    }
+
+    #[napi(ts_return_type = "text_index.TextRange")]
+    pub fn text_range(&self) -> TextRange {
+        self.0.range().into()
+    }
+
+    #[napi]
+    pub fn message(&self) -> String {
+        self.0.message()
+    }
+
+    #[napi]
+    pub fn code(&self) -> String {
+        self.0.code().unwrap_or_default().into_owned()
+    }
+}

crates/codegen/runtime/cargo/src/runtime/napi_interface/mod.rs

@@ -1,5 +1,6 @@
 pub mod cst;
 pub mod cursor;
+pub mod diagnostic;
 pub mod parse_error;
 pub mod parse_output;
 pub mod query;

crates/codegen/runtime/cargo/src/runtime/napi_interface/parse_error.rs

@@ -4,6 +4,7 @@
 use napi_derive::napi;
 use text_index::TextRange;
 
+use crate::napi_interface::diagnostic::Diagnostic;
 use crate::napi_interface::{text_index, RustParseError};
 
 #[napi(namespace = "parse_error")]
@@ -20,11 +21,13 @@ impl From<RustParseError> for ParseError {
 impl ParseError {
     #[napi(getter, ts_return_type = "text_index.TextRange", catch_unwind)]
     pub fn text_range(&self) -> TextRange {
-        self.0.text_range().into()
+        self.0.text_range().clone().into()
     }
 
-    #[napi(catch_unwind)]
-    pub fn to_error_report(&self, source_id: String, source: String, with_color: bool) -> String {
-        self.0.to_error_report(&source_id, &source, with_color)
+    #[napi(ts_return_type = "diagnostic.Diagnostic", catch_unwind)]
+    pub fn to_diagnostic(&self) -> Diagnostic {
+        // TODO: Figure out if we can auto-gen Diagnostics methods
+        // in TS for this implementor rather than having to clone here
+        Diagnostic(Box::new(self.0.clone()))
     }
 }

crates/codegen/runtime/cargo/src/runtime/napi_interface/text_index.rs

@@ -10,8 +10,8 @@ pub struct TextIndex {
     pub char: u32,
 }
 
-impl From<&RustTextIndex> for TextIndex {
-    fn from(value: &RustTextIndex) -> Self {
+impl From<RustTextIndex> for TextIndex {
+    fn from(value: RustTextIndex) -> Self {
         // We only support 32-byte indices on TS side.
         #[allow(clippy::cast_possible_truncation)]
         Self {
@@ -22,8 +22,8 @@ impl From<&RustTextIndex> for TextIndex {
     }
 }
 
-impl From<&TextIndex> for RustTextIndex {
-    fn from(value: &TextIndex) -> Self {
+impl From<TextIndex> for RustTextIndex {
+    fn from(value: TextIndex) -> Self {
         Self {
             utf8: value.utf8 as usize,
             utf16: value.utf16 as usize,
@@ -39,11 +39,11 @@ pub struct TextRange {
     pub end: TextIndex,
 }
 
-impl From<&RustTextRange> for TextRange {
-    fn from(value: &RustTextRange) -> Self {
+impl From<RustTextRange> for TextRange {
+    fn from(value: RustTextRange) -> Self {
         Self {
-            start: (&value.start).into(),
-            end: (&value.end).into(),
+            start: value.start.into(),
+            end: value.end.into(),
         }
     }
 }