fix: don't panic on malformed notification/request

asm-lsp/config_builder.rs

@@ -3,7 +3,7 @@ use std::string::ToString;
 use std::{env::current_dir, path::PathBuf};
 
 use anyhow::{Result, anyhow};
-use clap::{Args, arg};
+use clap::Args;
 use dialoguer::{Confirm, FuzzySelect, Input, theme::ColorfulTheme};
 use dirs::config_dir;
 

asm-lsp/handle.rs

@@ -25,6 +25,28 @@ use crate::{
     send_empty_resp, text_doc_change_to_ts_edit,
 };
 
+// A bug in Neovim can cause client->server RPC messages to be corrupted. If this
+// happens, log the error and return instead of panicking.
+macro_rules! cast_req {
+    ($req:expr, $r:ty) => {{
+        let Ok(request) = cast_req::<$r>($req) else {
+            error!("Failed to cast request of type {}", <$r>::METHOD);
+            return Ok(());
+        };
+        request
+    }};
+}
+
+macro_rules! cast_notif {
+    ($notif:expr, $r:ty) => {{
+        let Ok(notification) = cast_notif::<$r>($notif) else {
+            error!("Failed to cast notification of type {}", <$r>::METHOD);
+            return Ok(());
+        };
+        notification
+    }};
+}
+
 /// Handles `Request`s from the lsp client
 ///
 /// # Errors
@@ -46,7 +68,7 @@ pub fn handle_request(
     let start = std::time::Instant::now();
     match req.method.as_str() {
         HoverRequest::METHOD => {
-            let (id, params) = cast_req::<HoverRequest>(req).expect("Failed to cast hover request");
+            let (id, params) = cast_req!(req, HoverRequest);
             handle_hover_request(
                 connection,
                 id,
@@ -62,8 +84,7 @@ pub fn handle_request(
             );
         }
         Completion::METHOD => {
-            let (id, params) =
-                cast_req::<Completion>(req).expect("Failed to cast completion request");
+            let (id, params) = cast_req!(req, Completion);
             handle_completion_request(
                 connection,
                 id,
@@ -79,8 +100,7 @@ pub fn handle_request(
             );
         }
         GotoDefinition::METHOD => {
-            let (id, params) =
-                cast_req::<GotoDefinition>(req).expect("Failed to cast completion request");
+            let (id, params) = cast_req!(req, GotoDefinition);
             handle_goto_def_request(connection, id, &params, doc_store)?;
             info!(
                 "{} request serviced in {}ms",
@@ -89,8 +109,7 @@ pub fn handle_request(
             );
         }
         DocumentSymbolRequest::METHOD => {
-            let (id, params) =
-                cast_req::<DocumentSymbolRequest>(req).expect("Failed to cast completion request");
+            let (id, params) = cast_req!(req, DocumentSymbolRequest);
             handle_document_symbols_request(connection, id, &params, doc_store)?;
             info!(
                 "{} request serviced in {}ms",
@@ -99,8 +118,7 @@ pub fn handle_request(
             );
         }
         SignatureHelpRequest::METHOD => {
-            let (id, params) =
-                cast_req::<SignatureHelpRequest>(req).expect("Failed to cast completion request");
+            let (id, params) = cast_req!(req, SignatureHelpRequest);
             handle_signature_help_request(
                 connection,
                 id,
@@ -116,8 +134,7 @@ pub fn handle_request(
             );
         }
         References::METHOD => {
-            let (id, params) =
-                cast_req::<References>(req).expect("Failed to cast completion request");
+            let (id, params) = cast_req!(req, References);
             handle_references_request(connection, id, &params, doc_store)?;
             info!(
                 "{} request serviced in {}ms",
@@ -126,8 +143,7 @@ pub fn handle_request(
             );
         }
         DocumentDiagnosticRequest::METHOD => {
-            let (_id, params) = cast_req::<DocumentDiagnosticRequest>(req)
-                .expect("Failed to cast completion request");
+            let (_id, params) = cast_req!(req, DocumentDiagnosticRequest);
             let project_config = config.get_config(&params.text_document.uri);
             // Ok to unwrap, this should never be `None`
             if project_config.opts.as_ref().unwrap().diagnostics.unwrap() {
@@ -179,8 +195,7 @@ pub fn handle_notification(
     let start = std::time::Instant::now();
     match notif.method.as_str() {
         DidOpenTextDocument::METHOD => {
-            let params = cast_notif::<DidOpenTextDocument>(notif)
-                .expect("Failed to cast did open text document notification");
+            let params = cast_notif!(notif, DidOpenTextDocument);
             handle_did_open_text_document_notification(&params, doc_store);
             info!(
                 "{} notification serviced in {}ms",
@@ -189,8 +204,7 @@ pub fn handle_notification(
             );
         }
         DidChangeTextDocument::METHOD => {
-            let params = cast_notif::<DidChangeTextDocument>(notif)
-                .expect("Failed to cast did change text document notification");
+            let params = cast_notif!(notif, DidChangeTextDocument);
             handle_did_change_text_document_notification(&params, doc_store)?;
             info!(
                 "{} notification serviced in {}ms",
@@ -199,8 +213,7 @@ pub fn handle_notification(
             );
         }
         DidCloseTextDocument::METHOD => {
-            let params = cast_notif::<DidCloseTextDocument>(notif)
-                .expect("Failed to cast did close text document notification");
+            let params = cast_notif!(notif, DidCloseTextDocument);
             handle_did_close_text_document_notification(&params, doc_store);
             info!(
                 "{} notification serviced in {}ms",
@@ -209,8 +222,7 @@ pub fn handle_notification(
             );
         }
         DidSaveTextDocument::METHOD => {
-            let params = cast_notif::<DidSaveTextDocument>(notif)
-                .expect("Failed to cast did save text document notification");
+            let params = cast_notif!(notif, DidSaveTextDocument);
             let project_config = config.get_config(&params.text_document.uri);
             // Ok to unwrap, this should never be `None`
             if project_config.opts.as_ref().unwrap().diagnostics.unwrap() {

asm-lsp/lsp.rs

@@ -890,7 +890,7 @@ pub fn get_completes<T: Completable, U: ArchOrAssembler>(
             (
                 *arch_or_asm,
                 CompletionItem {
-                    label: (*name).to_string(),
+                    label: (*name).clone(),
                     kind,
                     documentation: Some(Documentation::MarkupContent(MarkupContent {
                         kind: MarkupKind::Markdown,

asm-lsp/parser.rs

@@ -762,11 +762,8 @@ pub fn populate_6502_instructions(html_conts: &str) -> Result<Vec<Instruction>>
         section_start + start_marker.len() + 1 // + 1 for '\n'
     };
     let mut lines = html_conts[start..].lines().peekable();
-    loop {
-        // opcode id
-        let Some(name_line) = lines.next() else {
-            break;
-        };
+    // opcode id
+    while let Some(name_line) = lines.next() {
         if name_line.is_empty() {
             continue;
         }

asm-lsp/test.rs

@@ -679,7 +679,7 @@ mod tests {
                 uri: uri.clone(),
                 language_id: "asm".to_string(),
                 version: 0,
-                text: source_code.to_string(),
+                text: source_code.clone(),
             },
         };
         let params = serde_json::to_value(did_open_params).unwrap();

asm-lsp/types.rs

@@ -437,11 +437,12 @@ pub struct AvrTiming {
 impl Display for AvrTiming {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Timing: ")?;
-        let mut has_prev = false;
-        if let Some(ref cycles) = self.avre {
+        let mut has_prev = if let Some(ref cycles) = self.avre {
             write!(f, "AVRE: {cycles}")?;
-            has_prev = true;
-        }
+            true
+        } else {
+            false
+        };
         if let Some(ref cycles) = self.avrxm {
             if has_prev {
                 write!(f, " | ")?;

asm_docs_parsing/src/main.rs

@@ -64,10 +64,7 @@ fn run(opts: &SerializeDocs) -> Result<()> {
             let instrs: Vec<Instruction>;
             match (path.is_dir(), opts.arch) {
                 (true, Some(arch_in)) => match arch_in {
-                    Arch::ARM => {
-                        instrs = populate_arm_instructions(&opts.input_path)?;
-                    }
-                    Arch::ARM64 => {
+                    Arch::ARM | Arch::ARM64 => {
                         instrs = populate_arm_instructions(&opts.input_path)?;
                     }
                     Arch::RISCV => {