Merge pull request #29420 from ProvableHQ/josh/diagnostics

feat(LSP) Implement diagnostics and error publishing.

Author: JoshuaBatty

crates/errors/src/common/backtraced.rs

@@ -117,6 +117,14 @@ impl Backtraced {
     pub fn warning_code(&self) -> String {
         format_warning_code(&self.type_, 37, self.code)
     }
+
+    /// Return whether this diagnostic represents an error rather than a warning.
+    ///
+    /// LSP severity mapping inspects this flag rather than the rendered prefix
+    /// in the diagnostic's `Display` output.
+    pub fn is_error(&self) -> bool {
+        self.error
+    }
 }
 
 impl fmt::Display for Backtraced {

crates/errors/src/common/formatted.rs

@@ -47,6 +47,22 @@ impl Label {
         self.color = color;
         self
     }
+
+    /// Borrow the secondary label's message without copying.
+    ///
+    /// Surfaced for `Formatted::diagnostic_view`, which lowers labels into
+    /// LSP-facing related-information entries without re-parsing rendered text.
+    pub fn message(&self) -> &str {
+        &self.msg
+    }
+
+    /// Return the secondary label's source span.
+    ///
+    /// Used by structured diagnostic consumers (notably `leo-lsp`) to convert
+    /// labels into UTF-16 ranges while the session source map is still alive.
+    pub fn span(&self) -> Span {
+        self.span
+    }
 }
 
 /// Helper span for Ariadne that includes the source file start index.
@@ -173,6 +189,83 @@ impl Formatted {
         format_warning_code(&self.inner.type_, 37, self.inner.code)
     }
 
+    /// Return the diagnostic's primary message without ariadne rendering.
+    ///
+    /// Used by tooling consumers (notably `leo-lsp`) that need the bare message
+    /// text rather than the formatted report. The returned slice borrows from
+    /// the same allocation as the rest of the diagnostic and therefore stays
+    /// valid for the lifetime of the `Formatted` value.
+    pub fn message(&self) -> &str {
+        &self.inner.message
+    }
+
+    /// Return the diagnostic's optional help text, if any.
+    ///
+    /// `leo-lsp` appends this to the LSP diagnostic message so editor clients
+    /// see the same hint that the CLI report would render.
+    pub fn help(&self) -> Option<&str> {
+        self.inner.help.as_deref()
+    }
+
+    /// Return the diagnostic's optional follow-up note text, if any.
+    ///
+    /// `leo-lsp` appends this to the LSP diagnostic message for parity with
+    /// CLI-rendered reports.
+    pub fn note(&self) -> Option<&str> {
+        self.inner.note.as_deref()
+    }
+
+    /// Return whether this diagnostic was raised as an error rather than a
+    /// warning.
+    ///
+    /// LSP severity mapping depends on this flag instead of inspecting the
+    /// rendered `Error`/`Warning` prefix in the formatted message.
+    pub fn is_error(&self) -> bool {
+        self.inner.error
+    }
+
+    /// Return the diagnostic's primary span.
+    ///
+    /// Callers must resolve this span against `leo_span` session globals to
+    /// recover the originating source file before the surrounding session is
+    /// torn down.
+    pub fn span(&self) -> Span {
+        self.inner.span
+    }
+
+    /// Iterate the diagnostic's secondary labels in declaration order.
+    ///
+    /// Labels carry their own span and human-readable message, which `leo-lsp`
+    /// surfaces as `Diagnostic.relatedInformation` when the client supports it.
+    pub fn labels(&self) -> impl Iterator<Item = &Label> {
+        self.inner.labels.iter()
+    }
+
+    /// Borrow this diagnostic as a plain structured view.
+    ///
+    /// The returned [`DiagnosticView`] exposes the same fields that are used
+    /// when rendering the ariadne report, without round-tripping through a
+    /// formatted string. Consumers like `leo-lsp` use the view to build LSP
+    /// `Diagnostic` payloads without parsing rendered output.
+    pub fn diagnostic_view(&self) -> DiagnosticView<'_> {
+        let code = if self.inner.error { self.error_code() } else { self.warning_code() };
+        let labels = self
+            .inner
+            .labels
+            .iter()
+            .map(|label| DiagnosticLabelView { message: label.message().to_owned(), span: label.span() })
+            .collect();
+        DiagnosticView {
+            message: &self.inner.message,
+            help: self.inner.help.as_deref(),
+            note: self.inner.note.as_deref(),
+            code,
+            is_error: self.inner.error,
+            span: Some(self.inner.span),
+            labels,
+        }
+    }
+
     /// Resolve a Leo `Span` to an `AriadneSpan` using the source map.
     fn resolve_span(span: Span, source_map: &leo_span::source_map::SourceMap) -> AriadneSpan {
         let file_start_index = source_map.find_source_file(span.lo).unwrap().absolute_start;
@@ -265,3 +358,91 @@ impl std::error::Error for Formatted {
         &self.inner.message
     }
 }
+
+/// LSP-agnostic structured view of a compiler diagnostic.
+///
+/// Exposed so editor tooling — currently `leo-lsp` — can lower errors and
+/// warnings into editor-facing diagnostics without parsing rendered ariadne
+/// output. The view borrows from the originating [`Formatted`] for cheap
+/// strings while owning a small per-label `Vec`, which is the smallest shape
+/// that keeps secondary-label messages alive across an `extract_errs` call.
+#[derive(Debug, Clone)]
+pub struct DiagnosticView<'a> {
+    /// Primary human-readable message.
+    pub message: &'a str,
+    /// Optional help hint shown beneath the diagnostic on the CLI.
+    pub help: Option<&'a str>,
+    /// Optional follow-up note shown beneath the help line on the CLI.
+    pub note: Option<&'a str>,
+    /// Fully formatted code identifier (e.g. `EPAR0001` or `WTYC0001`).
+    pub code: String,
+    /// Whether the diagnostic is an error (`true`) or a warning (`false`).
+    pub is_error: bool,
+    /// Primary span, when the diagnostic ties to a concrete source location.
+    pub span: Option<Span>,
+    /// Secondary spans annotated with their own human-readable messages.
+    pub labels: Vec<DiagnosticLabelView>,
+}
+
+/// One secondary label paired with its source span.
+///
+/// `leo-lsp` lowers each label into `Diagnostic.relatedInformation` when the
+/// client advertises support, so it captures both the span and the message.
+#[derive(Debug, Clone)]
+pub struct DiagnosticLabelView {
+    /// Human-readable description for the label.
+    pub message: String,
+    /// Span associated with the label, resolved against session source globals.
+    pub span: Span,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Color, Formatted, Label};
+    use leo_span::{Span, create_session_if_not_set_then};
+
+    /// Verifies the structured view round-trips primary message, code, help, and note.
+    #[test]
+    fn diagnostic_view_exposes_primary_fields() {
+        create_session_if_not_set_then(|_| {
+            let span = Span::default();
+            let error = Formatted::error("TST", 1, "boom", span).with_help("try again").with_note("note text");
+
+            let view = error.diagnostic_view();
+            assert_eq!(view.message, "boom");
+            assert_eq!(view.help, Some("try again"));
+            assert_eq!(view.note, Some("note text"));
+            assert_eq!(view.code, error.error_code());
+            assert!(view.is_error);
+            assert_eq!(view.span, Some(span));
+            assert!(view.labels.is_empty());
+        });
+    }
+
+    /// Verifies labels are exposed with their messages and spans intact.
+    #[test]
+    fn diagnostic_view_exposes_secondary_labels() {
+        create_session_if_not_set_then(|_| {
+            let primary = Span::new(0, 4);
+            let label_span = Span::new(5, 10);
+            let error = Formatted::error("TST", 2, "boom", primary)
+                .with_label(Label::new(label_span).with_message("see also").with_color(Color::Blue));
+
+            let view = error.diagnostic_view();
+            assert_eq!(view.labels.len(), 1);
+            assert_eq!(view.labels[0].message, "see also");
+            assert_eq!(view.labels[0].span, label_span);
+        });
+    }
+
+    /// Verifies warnings round-trip through the structured view with severity preserved.
+    #[test]
+    fn diagnostic_view_marks_warnings() {
+        create_session_if_not_set_then(|_| {
+            let warning = Formatted::warning("TST", 3, "watch out", Span::default());
+            let view = warning.diagnostic_view();
+            assert!(!view.is_error);
+            assert_eq!(view.code, warning.warning_code());
+        });
+    }
+}

crates/errors/src/errors/mod.rs

@@ -56,6 +56,36 @@ impl LeoError {
             SnarkVM(_) => 11000,
         }
     }
+
+    /// Borrow a structured, LSP-agnostic view of this error.
+    ///
+    /// Only [`LeoError::Formatted`] variants carry a span and labeled
+    /// secondary information, so other variants return `None`. The caller is
+    /// expected to fall back to a synthetic package-level diagnostic in that
+    /// case; see the `leo-lsp` diagnostics module for an example.
+    ///
+    /// [`LeoError::LastErrorCode`] is a sentinel used to signal that an error
+    /// has already been emitted through a handler. It deliberately returns
+    /// `None` so it is never published as a separate diagnostic.
+    pub fn diagnostic_view(&self) -> Option<crate::DiagnosticView<'_>> {
+        match self {
+            LeoError::Formatted(formatted) => Some(formatted.diagnostic_view()),
+            LeoError::Backtraced(_)
+            | LeoError::ConstEvalError(_)
+            | LeoError::LastErrorCode(_)
+            | LeoError::SnarkVM(_) => None,
+        }
+    }
+
+    /// Return whether this error is the sentinel raised after a handler emit.
+    ///
+    /// `Handler::last_err` produces [`LeoError::LastErrorCode`] when the
+    /// emitter has already buffered a real diagnostic. Consumers should skip
+    /// the sentinel when collecting structured diagnostics so the original
+    /// error is published exactly once.
+    pub fn is_last_error_code(&self) -> bool {
+        matches!(self, LeoError::LastErrorCode(_))
+    }
 }
 
 /// The LeoWarning type that contains all sub warning types.
@@ -72,6 +102,18 @@ impl LeoWarning {
             Formatted(w) => w.warning_code(),
         }
     }
+
+    /// Borrow a structured, LSP-agnostic view of this warning.
+    ///
+    /// Every variant currently wraps a [`Formatted`] payload, so the view is
+    /// always available. The signature is kept symmetric with
+    /// [`LeoError::diagnostic_view`] so future variants that lack span data
+    /// can opt out without breaking call sites.
+    pub fn diagnostic_view(&self) -> Option<crate::DiagnosticView<'_>> {
+        match self {
+            LeoWarning::Formatted(formatted) => Some(formatted.diagnostic_view()),
+        }
+    }
 }
 
 /// A global result type for all Leo crates, that defaults the errors to be a LeoError.

crates/lsp/Cargo.toml

@@ -43,5 +43,6 @@ tracing-subscriber = { workspace = true }
 xxhash-rust        = { workspace = true }
 
 [dev-dependencies]
-serde_json = { workspace = true }
-tempfile   = { workspace = true }
+crossbeam-channel = { workspace = true }
+serde_json        = { workspace = true }
+tempfile          = { workspace = true }