refactor goto defination, and support string references search

CppCXY · CppCXY · commit 965d40c5b66e · 2025-01-06T14:00:57.000+08:00
diff --git a/crates/code_analysis/src/compilation/analyzer/decl/exprs.rs b/crates/code_analysis/src/compilation/analyzer/decl/exprs.rs
@@ -1,6 +1,8 @@
 use emmylua_parser::{
-    LuaAstNode, LuaAstToken, LuaClosureExpr, LuaIndexExpr, LuaIndexKey, LuaNameExpr, LuaTableExpr,
+    LuaAstNode, LuaAstToken, LuaClosureExpr, LuaIndexExpr, LuaIndexKey, LuaLiteralExpr,
+    LuaLiteralToken, LuaNameExpr, LuaTableExpr,
 };
+use internment::ArcIntern;
 
 use crate::{
     db_index::{LuaDecl, LuaMember, LuaMemberKey, LuaMemberOwner},
@@ -162,3 +164,20 @@ pub fn analyze_table_expr(analyzer: &mut DeclAnalyzer, expr: LuaTableExpr) -> Op
 
     Some(())
 }
+
+pub fn analyze_literal_expr(analyzer: &mut DeclAnalyzer, expr: LuaLiteralExpr) -> Option<()> {
+    if let LuaLiteralToken::String(string_token) = expr.get_literal()? {
+        let file_id = analyzer.get_file_id();
+        let value = string_token.get_value();
+        if value.len() > 64 {
+            return Some(());
+        }
+
+        analyzer
+            .db
+            .get_reference_index_mut()
+            .add_string_reference(file_id, ArcIntern::new(value), string_token.get_range());
+    }
+
+    Some(())
+}
diff --git a/crates/code_analysis/src/compilation/analyzer/decl/mod.rs b/crates/code_analysis/src/compilation/analyzer/decl/mod.rs
@@ -72,6 +72,9 @@ fn walk_node_enter(analyzer: &mut DeclAnalyzer, node: LuaAst) {
         LuaAst::LuaTableExpr(expr) => {
             exprs::analyze_table_expr(analyzer, expr);
         }
+        LuaAst::LuaLiteralExpr(expr) => {
+            exprs::analyze_literal_expr(analyzer, expr);
+        }
         LuaAst::LuaDocTagClass(doc_tag) => {
             docs::analyze_doc_tag_class(analyzer, doc_tag);
         }
diff --git a/crates/code_analysis/src/db_index/reference/local_reference.rs b/crates/code_analysis/src/db_index/reference/local_reference.rs
@@ -1,13 +1,12 @@
 use std::collections::HashMap;
-
 use rowan::TextRange;
 
 use crate::db_index::LuaDeclId;
 
 #[derive(Debug)]
 pub struct LocalReference {
     local_references: HashMap<LuaDeclId, Vec<TextRange>>,
-    references_to_decl: HashMap<TextRange, LuaDeclId>
+    references_to_decl: HashMap<TextRange, LuaDeclId>,
 }
 
 impl LocalReference {
diff --git a/crates/code_analysis/src/db_index/reference/mod.rs b/crates/code_analysis/src/db_index/reference/mod.rs
@@ -1,11 +1,13 @@
 mod local_reference;
+mod string_reference;
 
 use std::collections::HashMap;
 
 use emmylua_parser::{LuaSyntaxId, LuaSyntaxKind};
 use internment::ArcIntern;
 use local_reference::LocalReference;
 use rowan::TextRange;
+use string_reference::StringReference;
 
 use crate::{FileId, InFiled};
 
@@ -15,13 +17,15 @@ use super::{traits::LuaIndex, LuaDeclId, LuaMemberKey};
 pub struct LuaReferenceIndex {
     local_references: HashMap<FileId, LocalReference>,
     index_reference: HashMap<LuaMemberKey, HashMap<FileId, Vec<LuaSyntaxId>>>,
+    string_references: HashMap<FileId, StringReference>,
 }
 
 impl LuaReferenceIndex {
     pub fn new() -> Self {
         Self {
             local_references: HashMap::new(),
             index_reference: HashMap::new(),
+            string_references: HashMap::new(),
         }
     }
 
@@ -56,6 +60,18 @@ impl LuaReferenceIndex {
             .push(syntax_id);
     }
 
+    pub fn add_string_reference(
+        &mut self,
+        file_id: FileId,
+        string: ArcIntern<String>,
+        range: TextRange,
+    ) {
+        self.string_references
+            .entry(file_id)
+            .or_insert_with(StringReference::new)
+            .add_string_reference(string, range);
+    }
+
     pub fn get_local_reference(&self, file_id: &FileId) -> Option<&LocalReference> {
         self.local_references.get(file_id)
     }
@@ -142,12 +158,29 @@ impl LuaReferenceIndex {
 
         Some(results)
     }
+
+    pub fn get_string_references(&self, string_value: &str) -> Vec<InFiled<TextRange>> {
+        let arc_string = ArcIntern::new(string_value.to_string());
+        let results = self
+            .string_references
+            .iter()
+            .map(|(file_id, string_reference)| {
+                string_reference
+                    .get_string_references(&arc_string)
+                    .into_iter()
+                    .map(|range| InFiled::new(*file_id, range))
+            })
+            .flatten()
+            .collect();
+
+        results
+    }
 }
 
 impl LuaIndex for LuaReferenceIndex {
     fn remove(&mut self, file_id: FileId) {
         self.local_references.remove(&file_id);
-
+        self.string_references.remove(&file_id);
         let mut to_be_remove = Vec::new();
         for (key, references) in self.index_reference.iter_mut() {
             references.remove(&file_id);
diff --git a/crates/code_analysis/src/db_index/reference/string_reference.rs b/crates/code_analysis/src/db_index/reference/string_reference.rs
@@ -0,0 +1,30 @@
+use internment::ArcIntern;
+use rowan::TextRange;
+use std::collections::HashMap;
+
+#[derive(Debug)]
+pub struct StringReference {
+    string_references: HashMap<ArcIntern<String>, Vec<TextRange>>,
+}
+
+impl StringReference {
+    pub fn new() -> Self {
+        Self {
+            string_references: HashMap::new(),
+        }
+    }
+
+    pub fn add_string_reference(&mut self, string: ArcIntern<String>, range: TextRange) {
+        self.string_references
+            .entry(string)
+            .or_insert_with(Vec::new)
+            .push(range);
+    }
+
+    pub fn get_string_references(&self, string: &ArcIntern<String>) -> Vec<TextRange> {
+        self.string_references
+            .get(string)
+            .cloned()
+            .unwrap_or_default()
+    }
+}
diff --git a/crates/emmylua_ls/src/handlers/defination/goto_def_defination.rs b/crates/emmylua_ls/src/handlers/defination/goto_def_defination.rs
@@ -0,0 +1,45 @@
+use code_analysis::{LuaPropertyOwnerId, SemanticModel};
+use lsp_types::GotoDefinitionResponse;
+
+pub fn goto_def_defination(
+    semantic_model: &SemanticModel,
+    property_owner: LuaPropertyOwnerId,
+) -> Option<GotoDefinitionResponse> {
+    match property_owner {
+        LuaPropertyOwnerId::LuaDecl(decl_id) => {
+            let decl = semantic_model
+                .get_db()
+                .get_decl_index()
+                .get_decl(&decl_id)?;
+            let document = semantic_model.get_document_by_file_id(decl_id.file_id)?;
+            let location = document.to_lsp_location(decl.get_range())?;
+            return Some(GotoDefinitionResponse::Scalar(location));
+        }
+        LuaPropertyOwnerId::Member(member_id) => {
+            let member = semantic_model
+                .get_db()
+                .get_member_index()
+                .get_member(&member_id)?;
+            let document = semantic_model.get_document_by_file_id(member_id.file_id)?;
+            let location = document.to_lsp_location(member.get_range())?;
+            return Some(GotoDefinitionResponse::Scalar(location));
+        }
+        LuaPropertyOwnerId::TypeDecl(type_decl_id) => {
+            let type_decl = semantic_model
+                .get_db()
+                .get_type_index()
+                .get_type_decl(&type_decl_id)?;
+            let mut locations = Vec::new();
+            for lua_location in type_decl.get_locations() {
+                let document = semantic_model.get_document_by_file_id(lua_location.file_id)?;
+                let location = document.to_lsp_location(lua_location.range)?;
+                locations.push(location);
+            }
+
+            return Some(GotoDefinitionResponse::Array(locations));
+        }
+        _ => {}
+    }
+
+    None
+}
diff --git a/crates/emmylua_ls/src/handlers/defination/goto_doc_see.rs b/crates/emmylua_ls/src/handlers/defination/goto_doc_see.rs
diff --git a/crates/emmylua_ls/src/handlers/defination/goto_module_file.rs b/crates/emmylua_ls/src/handlers/defination/goto_module_file.rs
@@ -0,0 +1,28 @@
+use code_analysis::SemanticModel;
+use emmylua_parser::LuaStringToken;
+use lsp_types::{GotoDefinitionResponse, Location};
+
+use crate::handlers::document_link::is_require_path;
+
+pub fn goto_module_file(
+    semantic_model: &SemanticModel,
+    string_token: LuaStringToken,
+) -> Option<GotoDefinitionResponse> {
+    let emmyrc = semantic_model.get_emmyrc();
+    if !is_require_path(string_token.clone(), &emmyrc).unwrap_or(false) {
+        return None;
+    }
+
+    let module_path = string_token.get_value();
+    let module_index = semantic_model.get_db().get_module_index();
+    let founded_module = module_index.find_module(&module_path)?;
+    let file_id = founded_module.file_id;
+    let document = semantic_model.get_document_by_file_id(file_id)?;
+    let uri = document.get_uri();
+    let lsp_range = document.get_document_lsp_range();
+
+    Some(GotoDefinitionResponse::Scalar(Location {
+        uri,
+        range: lsp_range,
+    }))
+}
diff --git a/crates/emmylua_ls/src/handlers/defination/mod.rs b/crates/emmylua_ls/src/handlers/defination/mod.rs
@@ -1,5 +1,10 @@
-use code_analysis::LuaPropertyOwnerId;
-use emmylua_parser::{LuaAstNode, LuaTokenKind};
+mod goto_def_defination;
+mod goto_doc_see;
+mod goto_module_file;
+
+use emmylua_parser::{LuaAstNode, LuaAstToken, LuaStringToken, LuaTokenKind};
+use goto_def_defination::goto_def_defination;
+use goto_module_file::goto_module_file;
 use lsp_types::{
     ClientCapabilities, GotoDefinitionParams, GotoDefinitionResponse, OneOf, ServerCapabilities,
 };
@@ -42,44 +47,13 @@ pub async fn on_goto_defination_handler(
         }
     };
 
-    let semantic_info = semantic_model.get_semantic_info(token.clone().into())?;
-    match semantic_info.property_owner? {
-        LuaPropertyOwnerId::LuaDecl(decl_id) => {
-            let decl = semantic_model
-                .get_db()
-                .get_decl_index()
-                .get_decl(&decl_id)?;
-            let document = semantic_model.get_document_by_file_id(decl_id.file_id)?;
-            let location = document.to_lsp_location(decl.get_range())?;
-            return Some(GotoDefinitionResponse::Scalar(location));
-        }
-        LuaPropertyOwnerId::Member(member_id) => {
-            let member = semantic_model
-                .get_db()
-                .get_member_index()
-                .get_member(&member_id)?;
-            let document = semantic_model.get_document_by_file_id(member_id.file_id)?;
-            let location = document.to_lsp_location(member.get_range())?;
-            return Some(GotoDefinitionResponse::Scalar(location));
-        }
-        LuaPropertyOwnerId::TypeDecl(type_decl_id) => {
-            let type_decl = semantic_model
-                .get_db()
-                .get_type_index()
-                .get_type_decl(&type_decl_id)?;
-            let mut locations = Vec::new();
-            for lua_location in type_decl.get_locations() {
-                let document = semantic_model.get_document_by_file_id(lua_location.file_id)?;
-                let location = document.to_lsp_location(lua_location.range)?;
-                locations.push(location);
-            }
-
-            return Some(GotoDefinitionResponse::Array(locations));
-        }
-        _ => {}
+    if let Some(property_owner) = semantic_model.get_property_owner_id(token.clone().into()) {
+        goto_def_defination(&semantic_model, property_owner);
+    } else if let Some(string_token) = LuaStringToken::cast(token) {
+        goto_module_file(&semantic_model, string_token);
     }
 
-    None
+    Some(GotoDefinitionResponse::Array(vec![]))
 }
 
 pub fn register_capabilities(
diff --git a/crates/emmylua_ls/src/handlers/document_link/build_link.rs b/crates/emmylua_ls/src/handlers/document_link/build_link.rs
@@ -103,7 +103,7 @@ fn try_build_module_link(
     Some(())
 }
 
-fn is_require_path(token: LuaStringToken, emmyrc: &Emmyrc) -> Option<bool> {
+pub fn is_require_path(token: LuaStringToken, emmyrc: &Emmyrc) -> Option<bool> {
     let call_expr_prefix = token
         .get_parent::<LuaLiteralExpr>()?
         .get_parent::<LuaCallArgList>()?
diff --git a/crates/emmylua_ls/src/handlers/document_link/mod.rs b/crates/emmylua_ls/src/handlers/document_link/mod.rs
@@ -6,8 +6,8 @@ use lsp_types::{
     ClientCapabilities, DocumentLink, DocumentLinkOptions, DocumentLinkParams, ServerCapabilities,
 };
 use tokio_util::sync::CancellationToken;
-
 use crate::context::ServerContextSnapshot;
+pub use build_link::is_require_path;
 
 pub async fn on_document_link_handler(
     context: ServerContextSnapshot,
diff --git a/crates/emmylua_ls/src/handlers/references/reference_seacher.rs b/crates/emmylua_ls/src/handlers/references/reference_seacher.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use code_analysis::{
     LuaCompilation, LuaDeclId, LuaMemberId, LuaMemberKey, LuaPropertyOwnerId, SemanticModel,
 };
-use emmylua_parser::{LuaAstNode, LuaSyntaxToken};
+use emmylua_parser::{LuaAstNode, LuaAstToken, LuaStringToken, LuaSyntaxToken};
 use lsp_types::Location;
 
 pub fn search_references(
@@ -12,15 +12,21 @@ pub fn search_references(
     token: LuaSyntaxToken,
 ) -> Option<Vec<Location>> {
     let mut result = Vec::new();
-    let semantic_info = semantic_model.get_semantic_info(token.into())?;
-    match semantic_info.property_owner? {
-        LuaPropertyOwnerId::LuaDecl(decl_id) => {
-            search_decl_references(semantic_model, decl_id, &mut result);
+    let semantic_info = semantic_model.get_semantic_info(token.clone().into());
+    if let Some(property_owner) = semantic_info?.property_owner {
+        match property_owner {
+            LuaPropertyOwnerId::LuaDecl(decl_id) => {
+                search_decl_references(semantic_model, decl_id, &mut result);
+            }
+            LuaPropertyOwnerId::Member(member_id) => {
+                search_member_references(semantic_model, compilation, member_id, &mut result);
+            }
+            _ => {}
         }
-        LuaPropertyOwnerId::Member(member_id) => {
-            search_member_references(semantic_model, compilation, member_id, &mut result);
-        }
-        _ => {}
+    } else if let Some(token) = LuaStringToken::cast(token) {
+        search_string_references(semantic_model, token, &mut result);
+    } else if semantic_model.get_emmyrc().references.fuzzy_search {
+        // todo!()
     }
 
     Some(result)
@@ -104,3 +110,23 @@ pub fn search_member_references(
 
     Some(())
 }
+
+fn search_string_references(
+    semantic_model: &SemanticModel,
+    token: LuaStringToken,
+    result: &mut Vec<Location>,
+) -> Option<()> {
+    let string_token_text = token.get_value();
+    let string_refs = semantic_model
+        .get_db()
+        .get_reference_index()
+        .get_string_references(&string_token_text);
+
+    for in_filed_reference_range in string_refs {
+        let document = semantic_model.get_document_by_file_id(in_filed_reference_range.file_id)?;
+        let location = document.to_lsp_location(in_filed_reference_range.value)?;
+        result.push(location);
+    }
+
+    Some(())
+}

Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,9 @@ fn walk_node_enter(analyzer: &mut DeclAnalyzer, node: LuaAst) {`
`72`	`72`	`LuaAst::LuaTableExpr(expr) => {`
`73`	`73`	`exprs::analyze_table_expr(analyzer, expr);`
`74`	`74`	`}`
	`75`	`+ LuaAst::LuaLiteralExpr(expr) => {`
	`76`	`+ exprs::analyze_literal_expr(analyzer, expr);`
	`77`	`+ }`
`75`	`78`	`LuaAst::LuaDocTagClass(doc_tag) => {`
`76`	`79`	`docs::analyze_doc_tag_class(analyzer, doc_tag);`
`77`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ fn try_build_module_link(`
`103`	`103`	`Some(())`
`104`	`104`	`}`
`105`	`105`
`106`		`-fn is_require_path(token: LuaStringToken, emmyrc: &Emmyrc) -> Option<bool> {`
	`106`	`+pub fn is_require_path(token: LuaStringToken, emmyrc: &Emmyrc) -> Option<bool> {`
`107`	`107`	`let call_expr_prefix = token`
`108`	`108`	`.get_parent::<LuaLiteralExpr>()?`
`109`	`109`	`.get_parent::<LuaCallArgList>()?`