Add diagnostics when decompilation fails for a procedure

Emit warning diagnostics when pseudocode generation fails, explaining why
decompilation failed and optionally pointing to related locations (e.g.,
a called procedure that couldn't be decompiled). These diagnostics only
appear when decompilation inlay hints are enabled.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: fegge

src/decompiler/collector.rs

@@ -9,7 +9,8 @@ use miden_assembly_syntax::ast::visit::{self, Visit};
 use miden_assembly_syntax::ast::{Block, Module, Op, Procedure};
 use miden_debug_types::{DefaultSourceManager, SourceSpan, Spanned};
 use tower_lsp::lsp_types::{
-    Diagnostic, DiagnosticSeverity, InlayHint, InlayHintKind, InlayHintLabel, Position, Range,
+    Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, InlayHint, InlayHintKind,
+    InlayHintLabel, Location, Position, Range, Url,
 };
 
 use crate::analysis::{
@@ -28,11 +29,25 @@ use super::state::DecompilerState;
 // Hint Collection Types
 // ═══════════════════════════════════════════════════════════════════════════
 
+/// Related information for a tracking failure diagnostic.
+#[derive(Clone)]
+pub struct RelatedInfo {
+    /// The span of the related location
+    pub span: SourceSpan,
+    /// Message explaining the related location
+    pub message: String,
+}
+
 /// A tracking failure that should be reported as a diagnostic.
 pub(crate) struct TrackingFailure {
+    /// The span where decompilation failed
     pub span: SourceSpan,
+    /// The reason for the failure
     pub reason: String,
+    /// The name of the procedure where failure occurred
     pub proc_name: String,
+    /// Optional related information (e.g., the root cause in another procedure)
+    pub related: Option<RelatedInfo>,
 }
 
 /// Collector that visits procedures and instructions.
@@ -466,10 +481,16 @@ impl<'a> Visit for DecompilationCollector<'a> {
         if let Some(ref state) = self.state {
             if state.tracking_failed {
                 if let (Some(span), Some(reason)) = (state.failure_span, state.failure_reason.clone()) {
+                    // Convert state's related info to TrackingFailure's related info
+                    let related = state.failure_related.as_ref().map(|r| RelatedInfo {
+                        span: r.span,
+                        message: r.message.clone(),
+                    });
                     self.failures.push(TrackingFailure {
                         span,
                         reason,
                         proc_name: proc_name.clone(),
+                        related,
                     });
                 }
                 // Remove all hints for this procedure when decompilation fails
@@ -558,6 +579,7 @@ pub struct DecompilationResult {
 pub fn collect_decompilation_hints(
     module: &Module,
     sources: &DefaultSourceManager,
+    uri: &Url,
     visible_range: &Range,
     tab_count: usize,
     source_text: &str,
@@ -621,17 +643,30 @@ pub fn collect_decompilation_hints(
         .into_iter()
         .filter_map(|failure| {
             let range = span_to_range(sources, failure.span)?;
+
+            // Convert related info to DiagnosticRelatedInformation
+            let related_information = failure.related.and_then(|related| {
+                let related_range = span_to_range(sources, related.span)?;
+                Some(vec![DiagnosticRelatedInformation {
+                    location: Location {
+                        uri: uri.clone(),
+                        range: related_range,
+                    },
+                    message: related.message,
+                }])
+            });
+
             Some(Diagnostic {
                 range,
-                severity: Some(DiagnosticSeverity::HINT),
+                severity: Some(DiagnosticSeverity::WARNING),
                 code: None,
                 code_description: None,
-                source: Some("masm-decompiler".to_string()),
+                source: Some("masm-lsp".to_string()),
                 message: format!(
-                    "Pseudocode unavailable beyond this point in '{}': {}",
+                    "Pseudocode unavailable in `{}`: {}",
                     failure.proc_name, failure.reason
                 ),
-                related_information: None,
+                related_information,
                 tags: None,
                 data: None,
             })

src/decompiler/mod.rs

@@ -19,7 +19,7 @@ pub use pseudocode::{
     apply_counter_indexing, binary_op_pseudocode, extract_declaration_prefix,
     format_invocation_target, format_procedure_signature, generate_pseudocode, rename_variable,
 };
-pub use state::{DecompilerState, NamedValue, SavedStackState, LOOP_COUNTER_NAMES};
+pub use state::{DecompilerState, FailureRelatedInfo, NamedValue, SavedStackState, LOOP_COUNTER_NAMES};
 
 #[cfg(test)]
 mod tests {

src/decompiler/pseudocode.rs

@@ -762,7 +762,7 @@ pub fn generate_pseudocode(
                 }
                 _ => {
                     // Unknown stack effect - fail tracking
-                    state.fail_tracking(span, &format!("procedure call to '{}' has unknown stack effect", name));
+                    state.fail_tracking(span, &format!("procedure call to `{}` has unknown stack effect", name));
                     Some(format!("call {}", name))
                 }
             }
@@ -773,7 +773,7 @@ pub fn generate_pseudocode(
             for _ in 0..4 {
                 state.pop_name();
             }
-            state.fail_tracking(span, "dynamic call has unknown stack effect");
+            state.fail_tracking(span, "dynamic call `dyn` has unknown stack effect");
             Some("call <dynamic>".to_string())
         }
 
@@ -910,7 +910,7 @@ pub fn generate_pseudocode(
         // Complex STARK operations - fail tracking (unknown effects)
         Instruction::FriExt2Fold4 | Instruction::HornerBase | Instruction::HornerExt |
         Instruction::EvalCircuit | Instruction::LogPrecompile => {
-            state.fail_tracking(span, &format!("complex STARK operation: {}", inst));
+            state.fail_tracking(span, &format!("complex STARK operation `{}`", inst));
             Some(format!("{}", inst))
         }
     }

src/decompiler/state.rs

@@ -24,6 +24,15 @@ pub struct SavedStackState {
     pub stack: Vec<NamedValue>,
 }
 
+/// Related information for a decompilation failure.
+#[derive(Debug, Clone)]
+pub struct FailureRelatedInfo {
+    /// The span of the related location
+    pub span: SourceSpan,
+    /// Message explaining the related location
+    pub message: String,
+}
+
 /// State for decompiling a procedure.
 ///
 /// Supports dynamic input discovery: when an operation tries to access a stack
@@ -43,6 +52,8 @@ pub struct DecompilerState {
     pub failure_span: Option<SourceSpan>,
     /// The reason tracking failed
     pub failure_reason: Option<String>,
+    /// Related information for the failure (e.g., root cause in called procedure)
+    pub failure_related: Option<FailureRelatedInfo>,
     /// Counter for generating loop counter names (c_1, c_2, ...)
     pub next_counter_id: usize,
     /// Span of a loop that produced a dynamic/unknown number of stack items.
@@ -73,6 +84,7 @@ impl DecompilerState {
             tracking_failed: false,
             failure_span: None,
             failure_reason: None,
+            failure_related: None,
             next_counter_id: 0,
             dynamic_stack_source: None,
         }
@@ -150,11 +162,25 @@ impl DecompilerState {
 
     /// Mark tracking as failed (e.g., after unknown procedure call).
     pub fn fail_tracking(&mut self, span: SourceSpan, reason: &str) {
+        self.fail_tracking_with_related(span, reason, None);
+    }
+
+    /// Mark tracking as failed with optional related information.
+    ///
+    /// The related information can point to the root cause of the failure,
+    /// such as a called procedure that couldn't be decompiled.
+    pub fn fail_tracking_with_related(
+        &mut self,
+        span: SourceSpan,
+        reason: &str,
+        related: Option<FailureRelatedInfo>,
+    ) {
         if !self.tracking_failed {
             // Only record the first failure
             self.tracking_failed = true;
             self.failure_span = Some(span);
             self.failure_reason = Some(reason.to_string());
+            self.failure_related = related;
         }
         self.stack.clear();
     }

src/server/mod.rs

@@ -19,9 +19,9 @@ use tower_lsp::{
         request::{GotoImplementationParams, GotoImplementationResponse},
         Diagnostic, GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverContents,
         HoverParams, InitializeParams, InitializeResult, InitializedParams, InlayHint,
-        InlayHintParams, Location, MarkupContent, MarkupKind, ReferenceParams, ServerCapabilities,
-        SymbolInformation, SymbolKind, TextDocumentContentChangeEvent, TextDocumentSyncCapability,
-        TextDocumentSyncKind, Url, WorkspaceSymbolParams,
+        InlayHintParams, Location, MarkupContent, MarkupKind, Position, Range, ReferenceParams,
+        ServerCapabilities, SymbolInformation, SymbolKind, TextDocumentContentChangeEvent,
+        TextDocumentSyncCapability, TextDocumentSyncKind, Url, WorkspaceSymbolParams,
     },
     LanguageServer,
 };
@@ -246,8 +246,11 @@ where
             None
         };
 
-        // Check if taint analysis is enabled
-        let taint_enabled = self.config.read().await.taint_analysis_enabled;
+        // Check configuration
+        let config = self.config.read().await;
+        let taint_enabled = config.taint_analysis_enabled;
+        let decompilation_enabled = config.inlay_hint_type == InlayHintType::Decompilation;
+        drop(config);
 
         // Then acquire a read lock on the workspace after parsing is done
         let workspace = self.workspace.read().await;
@@ -267,6 +270,27 @@ where
                     diags.extend(taint_diags);
                 }
 
+                // Run decompilation and collect failure diagnostics when decompilation hints are enabled
+                if decompilation_enabled {
+                    if let Some(source) = self.sources.get_by_uri(&to_miden_uri(&uri)) {
+                        // Use full document range for diagnostics
+                        let full_range = Range {
+                            start: Position { line: 0, character: 0 },
+                            end: Position { line: u32::MAX, character: 0 },
+                        };
+                        let decompilation_result = crate::decompiler::collect_decompilation_hints(
+                            &doc.module,
+                            self.sources.as_ref(),
+                            &uri,
+                            &full_range,
+                            0, // tab_count doesn't matter for diagnostics
+                            source.as_str(),
+                            Some(workspace.contracts()),
+                        );
+                        diags.extend(decompilation_result.diagnostics);
+                    }
+                }
+
                 diags
             }
             Err(report) => {
@@ -284,6 +308,26 @@ where
                         );
                         diags.extend(taint_diags);
                     }
+
+                    // Run decompilation on fallback doc if enabled
+                    if decompilation_enabled {
+                        if let Some(source) = self.sources.get_by_uri(&to_miden_uri(&uri)) {
+                            let full_range = Range {
+                                start: Position { line: 0, character: 0 },
+                                end: Position { line: u32::MAX, character: 0 },
+                            };
+                            let decompilation_result = crate::decompiler::collect_decompilation_hints(
+                                &doc.module,
+                                self.sources.as_ref(),
+                                &uri,
+                                &full_range,
+                                0,
+                                source.as_str(),
+                                Some(workspace.contracts()),
+                            );
+                            diags.extend(decompilation_result.diagnostics);
+                        }
+                    }
                 }
                 diags
             }
@@ -876,15 +920,15 @@ where
                 let result = crate::decompiler::collect_decompilation_hints(
                     &doc.module,
                     self.sources.as_ref(),
+                    &uri,
                     &params.range,
                     config.inlay_hint_tabs,
                     source.as_str(),
                     Some(contracts),
                 );
                 drop(workspace);
-                // Note: We could publish diagnostics here, but that would require
-                // storing them and publishing on document open/change. For now,
-                // the hints simply stop when tracking fails.
+                // Note: Decompilation failure diagnostics are published via
+                // publish_diagnostics when decompilation hints are enabled.
                 result.hints
             }
             InlayHintType::None => vec![],