Move helper functions from backend.rs to utils.rs

Author: Patotking12

lsp/src/backend.rs

@@ -14,14 +14,13 @@ use tower_lsp_server::lsp_types::{
     DidSaveTextDocumentParams, DocumentSymbol, DocumentSymbolParams, DocumentSymbolResponse,
     ExecuteCommandParams, GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverParams,
     HoverProviderCapability, InitializeParams, InitializeResult, InitializedParams, Location,
-    MarkupContent, MarkupKind, MessageType, OneOf, ParameterInformation, ParameterLabel, Range,
-    ReferenceParams, SaveOptions, SemanticToken, SemanticTokenModifier, SemanticTokenType,
-    SemanticTokens, SemanticTokensFullOptions, SemanticTokensLegend, SemanticTokensOptions,
-    SemanticTokensParams, SemanticTokensResult, SemanticTokensServerCapabilities,
-    ServerCapabilities, SignatureHelp, SignatureHelpOptions, SignatureHelpParams,
-    SignatureInformation, SymbolKind, TextDocumentSyncCapability, TextDocumentSyncKind,
-    TextDocumentSyncOptions, TextDocumentSyncSaveOptions, Uri, WorkDoneProgressOptions,
-    WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities,
+    MarkupContent, MarkupKind, MessageType, OneOf, Range, ReferenceParams, SaveOptions,
+    SemanticToken, SemanticTokenModifier, SemanticTokenType, SemanticTokens,
+    SemanticTokensFullOptions, SemanticTokensLegend, SemanticTokensOptions, SemanticTokensParams,
+    SemanticTokensResult, SemanticTokensServerCapabilities, ServerCapabilities, SignatureHelp,
+    SignatureHelpOptions, SignatureHelpParams, SymbolKind, TextDocumentSyncCapability,
+    TextDocumentSyncKind, TextDocumentSyncOptions, TextDocumentSyncSaveOptions, Uri,
+    WorkDoneProgressOptions, WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities,
 };
 use tower_lsp_server::{Client, LanguageServer};
 
@@ -37,7 +36,8 @@ use crate::completion::{self, CompletionProvider};
 use crate::error::LspError;
 use crate::function::Functions;
 use crate::utils::{
-    find_all_references, find_function_name_range, find_related_call, get_call_span,
+    create_signature_info, find_all_references, find_builtin_signature, find_function_call_context,
+    find_function_name_range, find_key_position, find_related_call, get_call_span,
     get_comments_from_lines, position_to_span, span_contains, span_to_positions,
 };
 
@@ -854,224 +854,6 @@ fn validate_witness_file(text: &str) -> Vec<Diagnostic> {
     diagnostics
 }
 
-/// Find the position of a key in the JSON text
-fn find_key_position(text: &str, key: &str) -> Option<tower_lsp_server::lsp_types::Position> {
-    let search = format!("\"{}\"", key);
-    for (line_num, line) in text.lines().enumerate() {
-        if let Some(col) = line.find(&search) {
-            return Some(tower_lsp_server::lsp_types::Position::new(
-                line_num as u32,
-                col as u32,
-            ));
-        }
-    }
-    None
-}
-
-/// Find the position of a value field within a witness object
-fn find_value_position(
-    text: &str,
-    witness_name: &str,
-    field_name: &str,
-) -> Option<tower_lsp_server::lsp_types::Position> {
-    let witness_search = format!("\"{}\"", witness_name);
-    let field_search = format!("\"{}\"", field_name);
-    let mut in_witness = false;
-
-    for (line_num, line) in text.lines().enumerate() {
-        if line.contains(&witness_search) {
-            in_witness = true;
-        }
-        if in_witness {
-            if let Some(col) = line.find(&field_search) {
-                return Some(tower_lsp_server::lsp_types::Position::new(
-                    line_num as u32,
-                    col as u32,
-                ));
-            }
-            // Check if we've exited the witness object (simple heuristic)
-            if line.trim() == "}," || line.trim() == "}" {
-                if !line.contains(&witness_search) {
-                    in_witness = false;
-                }
-            }
-        }
-    }
-    None
-}
-
-/// Find function call context from the current line.
-/// Returns (function_name, active_parameter_index) if inside a function call.
-fn find_function_call_context(line: &str) -> Option<(String, u32)> {
-    let mut paren_depth = 0;
-    let mut bracket_depth = 0;
-    let mut angle_depth = 0;
-    let mut last_open_paren = None;
-    let mut comma_count = 0;
-
-    // Scan from the end to find the innermost unclosed function call
-    for (i, ch) in line.chars().rev().enumerate() {
-        let pos = line.len() - 1 - i;
-        match ch {
-            ')' => paren_depth += 1,
-            '(' => {
-                if paren_depth > 0 {
-                    paren_depth -= 1;
-                } else {
-                    // Found unclosed '(' - this is our function call
-                    last_open_paren = Some(pos);
-                    break;
-                }
-            }
-            ']' => bracket_depth += 1,
-            '[' => {
-                if bracket_depth > 0 {
-                    bracket_depth -= 1;
-                }
-            }
-            '>' => angle_depth += 1,
-            '<' => {
-                if angle_depth > 0 {
-                    angle_depth -= 1;
-                }
-            }
-            ',' if paren_depth == 0 && bracket_depth == 0 && angle_depth == 0 => {
-                comma_count += 1;
-            }
-            _ => {}
-        }
-    }
-
-    let open_paren_pos = last_open_paren?;
-
-    // Extract function name before the '('
-    let before_paren = &line[..open_paren_pos];
-    let func_name = extract_function_name(before_paren)?;
-
-    Some((func_name, comma_count))
-}
-
-/// Extract function name from text before an opening parenthesis.
-/// Handles patterns like: `func_name`, `jet::add_32`, `fold::<f, 8>`
-fn extract_function_name(text: &str) -> Option<String> {
-    let trimmed = text.trim_end();
-
-    // Skip generic parameters if present (e.g., `fold::<f, 8>`)
-    let without_generics = if trimmed.ends_with('>') {
-        let mut depth = 0;
-        let mut start = None;
-        for (i, ch) in trimmed.chars().rev().enumerate() {
-            match ch {
-                '>' => depth += 1,
-                '<' => {
-                    depth -= 1;
-                    if depth == 0 {
-                        start = Some(trimmed.len() - 1 - i);
-                        break;
-                    }
-                }
-                _ => {}
-            }
-        }
-        match start {
-            Some(pos) => {
-                let before = &trimmed[..pos];
-                // Remove the `::` before `<` if present
-                before.strip_suffix("::").unwrap_or(before)
-            }
-            None => trimmed,
-        }
-    } else {
-        trimmed
-    };
-
-    // Now find the function name - it should be an identifier possibly with `::`
-    let mut name_chars = Vec::new();
-
-    for ch in without_generics.chars().rev() {
-        if ch.is_alphanumeric() || ch == '_' || ch == ':' {
-            name_chars.push(ch);
-        } else {
-            break;
-        }
-    }
-
-    if name_chars.is_empty() {
-        return None;
-    }
-
-    name_chars.reverse();
-    let name: String = name_chars.into_iter().collect();
-
-    // Clean up leading colons
-    let cleaned = name.trim_start_matches(':');
-    if cleaned.is_empty() {
-        None
-    } else {
-        Some(cleaned.to_string())
-    }
-}
-
-/// Create SignatureInformation from a FunctionTemplate.
-fn create_signature_info(template: &completion::types::FunctionTemplate) -> SignatureInformation {
-    let params: Vec<ParameterInformation> = template
-        .args
-        .iter()
-        .map(|arg| ParameterInformation {
-            label: ParameterLabel::Simple(arg.clone()),
-            documentation: None,
-        })
-        .collect();
-
-    let signature_label = format!(
-        "fn {}({}) -> {}",
-        template.display_name,
-        template.args.join(", "),
-        template.return_type
-    );
-
-    SignatureInformation {
-        label: signature_label,
-        documentation: if template.description.is_empty() {
-            None
-        } else {
-            Some(tower_lsp_server::lsp_types::Documentation::MarkupContent(
-                MarkupContent {
-                    kind: MarkupKind::Markdown,
-                    value: template.description.clone(),
-                },
-            ))
-        },
-        parameters: Some(params),
-        active_parameter: None,
-    }
-}
-
-/// Find signature for builtin functions.
-fn find_builtin_signature(name: &str) -> Option<SignatureInformation> {
-    use simplicityhl::parse::CallName;
-    use simplicityhl::str::AliasName;
-    use simplicityhl::types::AliasedType;
-
-    let ty = AliasedType::from(AliasName::from_str_unchecked("T"));
-
-    // Match common builtin function names
-    let call_name = match name {
-        "unwrap_left" => Some(CallName::UnwrapLeft(ty.clone())),
-        "unwrap_right" => Some(CallName::UnwrapRight(ty.clone())),
-        "unwrap" => Some(CallName::Unwrap),
-        "is_none" => Some(CallName::IsNone(ty.clone())),
-        "assert!" => Some(CallName::Assert),
-        "panic!" => Some(CallName::Panic),
-        "dbg!" => Some(CallName::Debug),
-        _ => None,
-    };
-
-    let call_name = call_name?;
-    let template = completion::builtin::match_callname(&call_name)?;
-    Some(create_signature_info(&template))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1118,78 +900,4 @@ mod tests {
         );
         assert!(doc.is_none(), "Expected no document to return");
     }
-
-    #[test]
-    fn test_extract_function_name() {
-        // Simple function name
-        assert_eq!(extract_function_name("foo"), Some("foo".to_string()));
-        assert_eq!(
-            extract_function_name("my_func"),
-            Some("my_func".to_string())
-        );
-
-        // With module prefix
-        assert_eq!(
-            extract_function_name("jet::add_32"),
-            Some("jet::add_32".to_string())
-        );
-
-        // With generic parameters
-        assert_eq!(
-            extract_function_name("fold::<f, 8>"),
-            Some("fold".to_string())
-        );
-        assert_eq!(
-            extract_function_name("unwrap_left::<u8>"),
-            Some("unwrap_left".to_string())
-        );
-
-        // With leading whitespace/expressions
-        assert_eq!(
-            extract_function_name("let x = foo"),
-            Some("foo".to_string())
-        );
-
-        // Empty input
-        assert_eq!(extract_function_name(""), None);
-    }
-
-    #[test]
-    fn test_find_function_call_context() {
-        // Simple function call
-        assert_eq!(
-            find_function_call_context("foo("),
-            Some(("foo".to_string(), 0))
-        );
-        assert_eq!(
-            find_function_call_context("foo(a, "),
-            Some(("foo".to_string(), 1))
-        );
-        assert_eq!(
-            find_function_call_context("foo(a, b, "),
-            Some(("foo".to_string(), 2))
-        );
-
-        // Nested function calls
-        assert_eq!(
-            find_function_call_context("foo(bar(x), "),
-            Some(("foo".to_string(), 1))
-        );
-
-        // Jet function
-        assert_eq!(
-            find_function_call_context("jet::add_32(a, "),
-            Some(("jet::add_32".to_string(), 1))
-        );
-
-        // With generic parameters
-        assert_eq!(
-            find_function_call_context("fold::<f, 8>(list, "),
-            Some(("fold".to_string(), 1))
-        );
-
-        // No function call context
-        assert_eq!(find_function_call_context("let x = 5"), None);
-        assert_eq!(find_function_call_context(""), None);
-    }
 }