chore(lsp): cleanup, resolve pedantic clippy

Author: gerau

lsp/src/backend.rs

@@ -190,7 +190,10 @@ impl LanguageServer for Backend {
         let uri = &params.text_document.uri;
 
         // .wit files don't have semantic tokens
-        if uri.path().as_str().ends_with(".wit") {
+        if std::path::Path::new(uri.path().as_str())
+            .extension()
+            .is_some_and(|ext| ext.eq_ignore_ascii_case("wit"))
+        {
             return Ok(None);
         }
 
@@ -207,7 +210,7 @@ impl LanguageServer for Backend {
         for func in &functions {
             // Add function name token (declaration)
             if let Ok(name_range) = find_function_name_range(func, &doc.text) {
-                let len = func.name().as_inner().len() as u32;
+                let len = u32::try_from(func.name().as_inner().len()).map_err(LspError::from)?;
                 raw_tokens.push((
                     name_range.start.line,
                     name_range.start.character,
@@ -222,7 +225,7 @@ impl LanguageServer for Backend {
                 .pre_order_iter()
                 .filter_map(|expr| {
                     if let parse::ExprTree::Call(call) = expr {
-                        get_call_span(call).ok().map(|span| (call, span))
+                        Some((call, get_call_span(call)))
                     } else {
                         None
                     }
@@ -249,8 +252,7 @@ impl LanguageServer for Backend {
                             // The function name starts after "jet::"
                             (semantic_token_types::FUNCTION, 5)
                         }
-                        parse::CallName::Custom(_) => (semantic_token_types::FUNCTION, 0),
-                        _ => (semantic_token_types::FUNCTION, 0), // Built-in functions
+                        _ => (semantic_token_types::FUNCTION, 0),
                     };
 
                     // Add the function name token
@@ -263,8 +265,8 @@ impl LanguageServer for Backend {
                     if func_name_len > 0 {
                         raw_tokens.push((
                             start.line,
-                            start.character + prefix_len as u32,
-                            func_name_len as u32,
+                            start.character + u32::try_from(prefix_len).map_err(LspError::from)?,
+                            u32::try_from(func_name_len).map_err(LspError::from)?,
                             token_type,
                             0,
                         ));
@@ -314,7 +316,10 @@ impl LanguageServer for Backend {
         let uri = &params.text_document.uri;
 
         // .wit files don't have symbols
-        if uri.path().as_str().ends_with(".wit") {
+        if std::path::Path::new(uri.path().as_str())
+            .extension()
+            .is_some_and(|ext| ext.eq_ignore_ascii_case("wit"))
+        {
             return Ok(None);
         }
 
@@ -391,9 +396,8 @@ impl LanguageServer for Backend {
             .unwrap_or_default();
 
         // Find function call context: look for unclosed '(' and count commas
-        let (func_name, active_param) = match find_function_call_context(&line_str) {
-            Some(ctx) => ctx,
-            None => return Ok(None),
+        let Some((func_name, active_param)) = find_function_call_context(&line_str) else {
+            return Ok(None);
         };
 
         // Try to find the function signature
@@ -465,7 +469,10 @@ impl LanguageServer for Backend {
         let uri = &params.text_document_position_params.text_document.uri;
 
         // .wit files don't have hover info
-        if uri.path().as_str().ends_with(".wit") {
+        if std::path::Path::new(uri.path().as_str())
+            .extension()
+            .is_some_and(|ext| ext.eq_ignore_ascii_case("wit"))
+        {
             return Ok(None);
         }
 
@@ -484,7 +491,7 @@ impl LanguageServer for Backend {
             return Ok(None);
         };
 
-        let call_span = get_call_span(call)?;
+        let call_span = get_call_span(call);
         let (start, end) = span_to_positions(&call_span, &doc.text)?;
 
         let description = match call.name() {
@@ -668,7 +675,10 @@ impl Backend {
     /// Function which executed on change of file (`did_save`, `did_open` or `did_change` methods)
     async fn on_change(&self, params: TextDocumentItem<'_>) {
         // Check if this is a witness file
-        if params.uri.path().as_str().ends_with(".wit") {
+        if std::path::Path::new(params.uri.path().as_str())
+            .extension()
+            .is_some_and(|ext| ext.eq_ignore_ascii_case("wit"))
+        {
             self.on_change_witness(params).await;
             return;
         }
@@ -764,74 +774,59 @@ fn parse_program(text: &str) -> (Vec<RichError>, Option<Document>) {
 fn validate_witness_file(text: &str) -> Vec<Diagnostic> {
     let mut diagnostics = Vec::new();
 
-    // Try to parse as JSON
     let json: serde_json::Value = match serde_json::from_str(text) {
         Ok(v) => v,
         Err(e) => {
-            // JSON parse error - find the position
-            let line = e.line().saturating_sub(1) as u32;
-            let col = e.column().saturating_sub(1) as u32;
+            let line = u32::try_from(e.line().saturating_sub(1)).unwrap_or(0);
+            let col = u32::try_from(e.column().saturating_sub(1)).unwrap_or(0);
             diagnostics.push(Diagnostic::new_simple(
                 Range::new(
                     tower_lsp_server::lsp_types::Position::new(line, col),
                     tower_lsp_server::lsp_types::Position::new(line, col + 1),
                 ),
-                format!("JSON syntax error: {}", e),
+                format!("JSON syntax error: {e}"),
             ));
             return diagnostics;
         }
     };
 
-    // Must be an object
-    let obj = match json.as_object() {
-        Some(o) => o,
-        None => {
-            diagnostics.push(Diagnostic::new_simple(
-                Range::new(
-                    tower_lsp_server::lsp_types::Position::new(0, 0),
-                    tower_lsp_server::lsp_types::Position::new(0, 1),
-                ),
-                "Witness file must be a JSON object".to_string(),
-            ));
-            return diagnostics;
-        }
+    let Some(obj) = json.as_object() else {
+        diagnostics.push(Diagnostic::new_simple(
+            Range::new(
+                tower_lsp_server::lsp_types::Position::new(0, 0),
+                tower_lsp_server::lsp_types::Position::new(0, 1),
+            ),
+            "Witness file must be a JSON object".to_string(),
+        ));
+        return diagnostics;
     };
 
-    // Validate each witness entry
     for (name, value) in obj {
-        let witness_obj = match value.as_object() {
-            Some(o) => o,
-            None => {
-                // Find approximate position for this key
-                if let Some(pos) = find_key_position(text, name) {
-                    diagnostics.push(Diagnostic::new_simple(
-                        Range::new(pos, pos),
-                        format!(
-                            "Witness '{}' must be an object with 'value' and 'type' fields",
-                            name
-                        ),
-                    ));
-                }
-                continue;
+        let Some(witness_obj) = value.as_object() else {
+            // Find approximate position for this key
+            if let Some(pos) = find_key_position(text, name) {
+                diagnostics.push(Diagnostic::new_simple(
+                    Range::new(pos, pos),
+                    format!("Witness '{name}' must be an object with 'value' and 'type' fields"),
+                ));
             }
+            continue;
         };
 
-        // Check for required 'value' field
         if !witness_obj.contains_key("value") {
             if let Some(pos) = find_key_position(text, name) {
                 diagnostics.push(Diagnostic::new_simple(
                     Range::new(pos, pos),
-                    format!("Witness '{}' is missing required 'value' field", name),
+                    format!("Witness '{name}' is missing required 'value' field"),
                 ));
             }
         }
 
-        // Check for required 'type' field
         if !witness_obj.contains_key("type") {
             if let Some(pos) = find_key_position(text, name) {
                 diagnostics.push(Diagnostic::new_simple(
                     Range::new(pos, pos),
-                    format!("Witness '{}' is missing required 'type' field", name),
+                    format!("Witness '{name}' is missing required 'type' field"),
                 ));
             }
         }

lsp/src/utils.rs

@@ -157,7 +157,7 @@ pub fn find_related_call<'a>(
         .filter_map(|expr| {
             if let parse::ExprTree::Call(call) = expr {
                 // Only include if call span can be obtained
-                get_call_span(call).ok().map(|span| (call, span))
+                Some((call, get_call_span(call)))
             } else {
                 None
             }
@@ -207,15 +207,13 @@ pub fn find_function_name_range(
     Ok(lsp_types::Range { start, end })
 }
 
-pub fn get_call_span(
-    call: &simplicityhl::parse::Call,
-) -> Result<simplicityhl::error::Span, LspError> {
+pub fn get_call_span(call: &simplicityhl::parse::Call) -> simplicityhl::error::Span {
     let length = call.name().to_string().len();
 
-    Ok(simplicityhl::error::Span {
+    simplicityhl::error::Span {
         start: call.span().start,
         end: call.span().start + length,
-    })
+    }
 }
 
 pub fn find_all_references<'a>(
@@ -230,7 +228,7 @@ pub fn find_all_references<'a>(
                 .pre_order_iter()
                 .filter_map(|expr| {
                     if let parse::ExprTree::Call(call) = expr {
-                        get_call_span(call).ok().map(|span| (call, span))
+                        Some((call, get_call_span(call)))
                     } else {
                         None
                     }
@@ -248,17 +246,20 @@ pub fn find_all_references<'a>(
 
 /// Find the position of a key in the JSON text
 pub fn find_key_position(text: &str, key: &str) -> Option<lsp_types::Position> {
-    let search = format!("\"{}\"", key);
+    let search = format!("\"{key}\"");
     for (line_num, line) in text.lines().enumerate() {
         if let Some(col) = line.find(&search) {
-            return Some(lsp_types::Position::new(line_num as u32, col as u32));
+            return Some(lsp_types::Position::new(
+                u32::try_from(line_num).ok()?,
+                u32::try_from(col).ok()?,
+            ));
         }
     }
     None
 }
 
 /// Find function call context from the current line.
-/// Returns (function_name, active_parameter_index) if inside a function call.
+/// Returns (`function_name`, `active_parameter_index`) if inside a function call.
 pub fn find_function_call_context(line: &str) -> Option<(String, u32)> {
     let mut paren_depth = 0;
     let mut bracket_depth = 0;
@@ -369,7 +370,7 @@ pub fn extract_function_name(text: &str) -> Option<String> {
     }
 }
 
-/// Create SignatureInformation from a FunctionTemplate.
+/// Create `SignatureInformation` from a `FunctionTemplate`.
 pub fn create_signature_info(
     template: &completion::types::FunctionTemplate,
 ) -> SignatureInformation {