Improve find referenced symbols

lsproxy/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lsproxy"
-version = "0.3.2"
+version = "0.3.3"
 edition = "2021"
 
 [lib]

lsproxy/src/ast_grep/client.rs

@@ -53,6 +53,21 @@ impl AstGrepClient {
         self.scan_file(IDENTIFIER_CONFIG_PATH, file_name).await
     }
 
+    pub async fn get_symbol_and_references(
+        &self,
+        file_name: &str,
+        position: &lsp_types::Position,
+        full_scan: bool,
+    ) -> Result<(AstGrepMatch, Vec<AstGrepMatch>), Box<dyn std::error::Error>> {
+        let symbol_match = self
+            .get_symbol_match_from_position(file_name, position)
+            .await?;
+        let references = self
+            .get_references_contained_in_symbol_match(file_name, &symbol_match, full_scan)
+            .await?;
+        Ok((symbol_match, references))
+    }
+
     pub async fn get_references_contained_in_symbol_match(
         &self,
         file_name: &str,
@@ -67,8 +82,7 @@ impl AstGrepClient {
         let contained_references = matches
             .into_iter()
             .filter(|m| {
-                let contained = symbol_match
-                    .contains(m);
+                let contained = symbol_match.contains(m);
 
                 contained && (full_scan || m.rule_id != "non-function")
             })

lsproxy/src/ast_grep/types.rs

@@ -46,25 +46,10 @@ impl AstGrepMatch {
         self.file == other.file
             && self.get_context_range().start.line <= other.get_context_range().start.line
             && self.get_context_range().end.line >= other.get_context_range().end.line
-            && (self.get_context_range().start.line != other.get_context_range().start.line || self.get_context_range().start.column <= other.get_context_range().start.column)
-            && (self.get_context_range().end.line != other.get_context_range().end.line || self.get_context_range().end.column >= other.get_context_range().end.column)
-    }
-
-    pub fn contains_location(&self, loc: &lsp_types::Location) -> bool {
-        self.file == loc.uri.path()
-            && self.get_context_range().start.line <= loc.range.start.line
-            && self.get_context_range().end.line >= loc.range.end.line
-            && (self.get_context_range().start.line != loc.range.start.line || self.get_context_range().start.column <= loc.range.start.character)
-            && (self.get_context_range().end.line != loc.range.end.line || self.get_context_range().end.column >= loc.range.end.character)
-
-    }
-
-    pub fn contains_locationlink(&self, link: &lsp_types::LocationLink) -> bool {
-        self.file == link.target_uri.path()
-            && self.get_context_range().start.line <= link.target_range.start.line
-            && self.get_context_range().end.line >= link.target_range.end.line
-            && (self.get_context_range().start.line != link.target_range.start.line || self.get_context_range().start.column <= link.target_range.start.character)
-            && (self.get_context_range().end.line != link.target_range.end.line || self.get_context_range().end.column >= link.target_range.end.character)
+            && (self.get_context_range().start.line != other.get_context_range().start.line
+                || self.get_context_range().start.column <= other.get_context_range().start.column)
+            && (self.get_context_range().end.line != other.get_context_range().end.line
+                || self.get_context_range().end.column >= other.get_context_range().end.column)
     }
 }
 

lsproxy/src/handlers/definitions_in_file.rs

@@ -1,6 +1,6 @@
 use actix_web::web::{Data, Query};
 use actix_web::HttpResponse;
-use log::{error, info};
+use log::info;
 
 use crate::api_types::{ErrorResponse, FileSymbolsRequest, Symbol};
 use crate::AppState;
@@ -40,16 +40,12 @@ pub async fn definitions_in_file(
         "Received definitions in file request for file: {}",
         info.file_path
     );
-    let manager = match data.manager.lock() {
-        Ok(guard) => guard,
-        Err(e) => {
-            error!("Failed to acquire lock on LSP manager: {}", e);
-            return HttpResponse::InternalServerError().json(ErrorResponse {
-                error: "Internal server error".to_string(),
-            });
-        }
-    };
-    match manager.definitions_in_file_ast_grep(&info.file_path).await {
+
+    match data
+        .manager
+        .definitions_in_file_ast_grep(&info.file_path)
+        .await
+    {
         Ok(symbols) => {
             let symbol_response: Vec<Symbol> = symbols
                 .into_iter()

lsproxy/src/handlers/error.rs

@@ -11,19 +11,21 @@ impl IntoHttpResponse for LspManagerError {
         log::error!("LSP error: {}", self);
         match self {
             Self::FileNotFound(path) => HttpResponse::BadRequest().json(ErrorResponse {
-                error: format!("File not found: {}", path)
-            }),
-            Self::LspClientNotFound(lang) => HttpResponse::InternalServerError().json(ErrorResponse {
-                error: format!("LSP client not found for {:?}", lang)
+                error: format!("File not found: {}", path),
             }),
+            Self::LspClientNotFound(lang) => {
+                HttpResponse::InternalServerError().json(ErrorResponse {
+                    error: format!("LSP client not found for {:?}", lang),
+                })
+            }
             Self::InternalError(msg) => HttpResponse::InternalServerError().json(ErrorResponse {
-                error: format!("Internal error: {}", msg)
+                error: format!("Internal error: {}", msg),
             }),
             Self::UnsupportedFileType(path) => HttpResponse::BadRequest().json(ErrorResponse {
-                error: format!("Unsupported file type: {}", path)
+                error: format!("Unsupported file type: {}", path),
             }),
             Self::NotImplemented(msg) => HttpResponse::NotImplemented().json(ErrorResponse {
-                error: format!("Not implemented: {}", msg)
+                error: format!("Not implemented: {}", msg),
             }),
         }
     }

lsproxy/src/handlers/find_definition.rs

@@ -49,16 +49,7 @@ pub async fn find_definition(
         info.position.path, info.position.position.line, info.position.position.character
     );
 
-    let manager = match data.manager.lock() {
-        Ok(manager) => manager,
-        Err(e) => {
-            error!("Failed to lock manager: {:?}", e);
-            return HttpResponse::InternalServerError().json(ErrorResponse {
-                error: format!("Failed to lock manager: {}", e),
-            });
-        }
-    };
-    let file_identifiers = match manager.get_file_identifiers(&info.position.path).await {
+    let file_identifiers = match data.manager.get_file_identifiers(&info.position.path).await {
         Ok(identifiers) => identifiers,
         Err(e) => {
             error!("Failed to get file identifiers: {:?}", e);
@@ -78,7 +69,8 @@ pub async fn find_definition(
             }
         };
 
-    let definitions = match manager
+    let definitions = match data
+        .manager
         .find_definition(
             &info.position.path,
             LspPosition {
@@ -95,7 +87,7 @@ pub async fn find_definition(
     };
 
     let source_code_context = if info.include_source_code {
-        match fetch_definition_source_code(&manager, &definitions).await {
+        match fetch_definition_source_code(&data.manager, &definitions).await {
             Ok(context) => Some(context),
             Err(e) => {
                 error!("Failed to fetch definition source code: {:?}", e);

lsproxy/src/handlers/find_identifier.rs

@@ -46,16 +46,7 @@ pub async fn find_identifier(
         "Received identifier request for file: {}, name: {}, position: {:?}",
         info.path, info.name, info.position
     );
-    let manager = match data.manager.lock() {
-        Ok(manager) => manager,
-        Err(e) => {
-            error!("Failed to lock manager: {:?}", e);
-            return HttpResponse::InternalServerError().json(ErrorResponse {
-                error: format!("Failed to lock manager: {}", e),
-            });
-        }
-    };
-    let file_identifiers = match manager.get_file_identifiers(&info.path).await {
+    let file_identifiers = match data.manager.get_file_identifiers(&info.path).await {
         Ok(identifiers) => identifiers,
         Err(e) => {
             error!("Failed to get file identifiers: {:?}", e);