refactor signature

Author: CppCXY

crates/code_analysis/src/compilation/analyzer/decl/exprs.rs

@@ -79,7 +79,7 @@ pub fn analyze_closure_expr(analyzer: &mut DeclAnalyzer, expr: LuaClosureExpr) -
     let params = expr.get_params_list()?;
     let signature_id = LuaSignatureId::new(analyzer.get_file_id(), &expr);
 
-    for param in params.get_params() {
+    for (idx, param) in params.get_params().enumerate() {
         let name = param.get_name_token().map_or_else(
             || {
                 if param.is_dots() {
@@ -95,12 +95,40 @@ pub fn analyze_closure_expr(analyzer: &mut DeclAnalyzer, expr: LuaClosureExpr) -
             name,
             file_id: analyzer.get_file_id(),
             range: param.get_range(),
+            idx,
             signature_id,
         };
 
         analyzer.add_decl(decl);
     }
 
+    analyze_closure_params(analyzer, &signature_id, &expr);
+
+    Some(())
+}
+
+fn analyze_closure_params(
+    analyzer: &mut DeclAnalyzer,
+    signature_id: &LuaSignatureId,
+    closure: &LuaClosureExpr,
+) -> Option<()> {
+    let signature = analyzer
+        .db
+        .get_signature_index_mut()
+        .get_or_create(signature_id.clone());
+    let params = closure.get_params_list()?.get_params();
+    for param in params {
+        let name = if let Some(name_token) = param.get_name_token() {
+            name_token.get_name_text().to_string()
+        } else if param.is_dots() {
+            "...".to_string()
+        } else {
+            return None;
+        };
+
+        signature.params.push(name);
+    }
+
     Some(())
 }
 

crates/code_analysis/src/compilation/analyzer/doc/file_generic_index.rs

@@ -95,8 +95,7 @@ impl FileGenericIndex {
         for effect_id in self.root_node_ids.iter() {
             if self
                 .effect_nodes
-                .get(effect_id.id)
-                .unwrap()
+                .get(effect_id.id)?
                 .range
                 .contains(position)
             {

crates/code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs

@@ -123,7 +123,10 @@ pub fn analyze_param(analyzer: &mut DocAnalyzer, tag: LuaDocTagParam) -> Option<
             nullable,
             description,
         };
-        signature.param_docs.insert(name.clone(), param_info);
+
+        let idx = signature.find_param_idx(&name)?;
+
+        signature.param_docs.insert(idx, param_info);
 
         let param_list = closure.get_params_list()?;
         for param in param_list.get_params() {

crates/code_analysis/src/compilation/analyzer/lua/closure.rs

@@ -13,7 +13,6 @@ pub fn analyze_closure(analyzer: &mut LuaAnalyzer, closure: LuaClosureExpr) -> O
     let signature_id = LuaSignatureId::new(analyzer.file_id, &closure);
 
     analyze_colon_define(analyzer, &signature_id, &closure);
-    analyze_params(analyzer, &signature_id, &closure);
     analyze_lambda_params(analyzer, &signature_id, &closure);
     analyze_return(analyzer, &signature_id, &closure);
     Some(())
@@ -39,31 +38,6 @@ fn analyze_colon_define(
     Some(())
 }
 
-fn analyze_params(
-    analyzer: &mut LuaAnalyzer,
-    signature_id: &LuaSignatureId,
-    closure: &LuaClosureExpr,
-) -> Option<()> {
-    let signature = analyzer
-        .db
-        .get_signature_index_mut()
-        .get_or_create(signature_id.clone());
-    let params = closure.get_params_list()?.get_params();
-    for param in params {
-        let name = if let Some(name_token) = param.get_name_token() {
-            name_token.get_name_text().to_string()
-        } else if param.is_dots() {
-            "...".to_string()
-        } else {
-            return None;
-        };
-
-        signature.params.push(name);
-    }
-
-    Some(())
-}
-
 fn analyze_lambda_params(
     analyzer: &mut LuaAnalyzer,
     signature_id: &LuaSignatureId,

crates/code_analysis/src/compilation/analyzer/unresolve/resolve_closure_param.rs

@@ -42,14 +42,15 @@ pub fn try_resolve_closure_params(
             return Some(true);
         };
 
+    
     let signature_params = &mut signature.param_docs;
-    for (name, type_ref) in expr_closure_params {
-        if signature_params.contains_key(name) {
+    for (idx, (name, type_ref)) in expr_closure_params.iter().enumerate() {
+        if signature_params.contains_key(&idx) {
             continue;
         }
 
         signature_params.insert(
-            name.clone(),
+            idx,
             LuaDocParamInfo {
                 name: name.clone(),
                 type_ref: type_ref.clone().unwrap_or(LuaType::Any),

crates/code_analysis/src/db_index/declaration/decl.rs

@@ -21,6 +21,7 @@ pub enum LuaDecl {
         name: String,
         file_id: FileId,
         range: TextRange,
+        idx: usize,
         signature_id: LuaSignatureId,
     },
     Global {

crates/code_analysis/src/db_index/reference/mod.rs

@@ -95,7 +95,7 @@ impl LuaReferenceIndex {
             .get(&LuaMemberKey::Name(ArcIntern::new(name.to_string())))?
             .iter()
             .filter_map(|(key_file_id, syntax_ids)| {
-                if *key_file_id != file_id {
+                if *key_file_id == file_id {
                     Some(syntax_ids.iter().map(|syntax_id| syntax_id.get_range()))
                 } else {
                     None

crates/code_analysis/src/db_index/signature/signature.rs

@@ -15,7 +15,7 @@ use crate::{
 pub struct LuaSignature {
     pub generic_params: Vec<(String, Option<LuaType>)>,
     pub overloads: Vec<Arc<LuaFunctionType>>,
-    pub param_docs: HashMap<String, LuaDocParamInfo>,
+    pub param_docs: HashMap<usize, LuaDocParamInfo>,
     pub params: Vec<String>,
     pub return_docs: Vec<LuaDocReturnInfo>,
     pub(crate) resolve_return: bool,
@@ -45,8 +45,8 @@ impl LuaSignature {
 
     pub fn get_type_params(&self) -> Vec<(String, Option<LuaType>)> {
         let mut type_params = Vec::new();
-        for param_name in &self.params {
-            if let Some(param_info) = self.param_docs.get(param_name) {
+        for (idx, param_name) in self.params.iter().enumerate() {
+            if let Some(param_info) = self.param_docs.get(&idx) {
                 type_params.push((param_name.clone(), Some(param_info.type_ref.clone())));
             } else {
                 type_params.push((param_name.clone(), None));
@@ -56,8 +56,26 @@ impl LuaSignature {
         type_params
     }
 
-    pub fn get_param_doc(&self, param_name: &str) -> Option<&LuaDocParamInfo> {
-        self.param_docs.get(param_name)
+    pub fn find_param_idx(&self, param_name: &str) -> Option<usize> {
+        self.params.iter().position(|name| name == param_name)
+    }
+
+    pub fn get_param_info_by_name(&self, param_name: &str) -> Option<&LuaDocParamInfo> {
+        // fast enough
+        let idx = self.params.iter().position(|name| name == param_name)?;
+        self.param_docs.get(&idx)
+    }
+
+    pub fn get_param_info_by_id(&self, idx: usize) -> Option<&LuaDocParamInfo> {
+        if idx < self.params.len() {
+            return self.param_docs.get(&idx);
+        } else if let Some(name) = self.params.last() {
+            if name == "..." {
+                return self.param_docs.get(&(self.params.len() - 1));
+            }
+        }
+
+        None
     }
 }
 

crates/code_analysis/src/semantic/infer/infer_name.rs

@@ -34,16 +34,19 @@ pub fn infer_name_expr(
         } else if decl.is_param() {
             match decl {
                 LuaDecl::Param {
-                    name, signature_id, ..
+                    idx, signature_id, ..
                 } => {
                     let signature = db.get_signature_index().get(&signature_id)?;
-                    let param_info = signature.get_param_doc(&name)?;
-                    let mut typ = param_info.type_ref.clone();
-                    if param_info.nullable && !typ.is_nullable() {
-                        typ = LuaType::Nullable(typ.into());
-                    }
+                    if let Some(param_info) = signature.get_param_info_by_id(*idx) {
+                        let mut typ = param_info.type_ref.clone();
+                        if param_info.nullable && !typ.is_nullable() {
+                            typ = LuaType::Nullable(typ.into());
+                        }
 
-                    typ
+                        typ
+                    } else {
+                        LuaType::Unknown
+                    }
                 }
                 _ => unreachable!(),
             }

crates/code_analysis/src/semantic/semantic_info/mod.rs

@@ -42,10 +42,10 @@ pub fn infer_token_semantic_info(
             let decl = db.get_decl_index().get_decl(&decl_id)?;
             match decl {
                 LuaDecl::Param {
-                    name, signature_id, ..
+                    idx, signature_id, ..
                 } => {
                     let signature = db.get_signature_index().get(&signature_id)?;
-                    let param_info = signature.get_param_doc(&name)?;
+                    let param_info = signature.get_param_info_by_id(*idx)?;
                     let mut typ = param_info.type_ref.clone();
                     if param_info.nullable && !typ.is_nullable() {
                         typ = LuaType::Nullable(typ.into());