fix goto_function

Author: xuhuanzy

crates/emmylua_ls/src/handlers/definition/goto_function.rs

@@ -1,8 +1,10 @@
 use emmylua_code_analysis::{
-    LuaCompilation, LuaDeclId, LuaFunctionType, LuaMemberId, LuaSemanticDeclId, LuaSignature,
-    LuaSignatureId, LuaType, SemanticDeclLevel, SemanticModel, instantiate_func_generic,
+    LuaCompilation, LuaDeclId, LuaFunctionType, LuaSemanticDeclId, LuaSignature, LuaSignatureId,
+    LuaType, SemanticDeclLevel, SemanticModel, instantiate_func_generic,
+};
+use emmylua_parser::{
+    LuaAstNode, LuaCallExpr, LuaExpr, LuaLiteralToken, LuaSyntaxToken, LuaTokenKind,
 };
-use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaSyntaxToken, LuaTokenKind};
 use rowan::{NodeOrToken, TokenAtOffset};
 use std::sync::Arc;
 
@@ -27,17 +29,44 @@ pub fn find_matching_function_definitions(
     let mut has_match = false;
 
     for (decl, member_id) in member_decls {
-        if process_member_function_type(
-            semantic_model,
-            compilation,
-            &call_function,
-            &call_expr,
-            decl,
-            member_id,
-            &mut result,
-            &mut has_match,
-        ) {
-            continue;
+        let typ = semantic_model.get_type(member_id.clone().into());
+        match typ {
+            LuaType::DocFunction(func) => {
+                if compare_function_types(semantic_model, &call_function, &func, &call_expr)
+                    .unwrap_or(false)
+                {
+                    result.push(decl.clone());
+                    has_match = true;
+                }
+            }
+            LuaType::Signature(signature_id) => {
+                let signature = match semantic_model
+                    .get_db()
+                    .get_signature_index()
+                    .get(&signature_id)
+                {
+                    Some(sig) => sig,
+                    None => continue,
+                };
+                let functions = get_signature_functions(signature);
+
+                if functions.iter().any(|func| {
+                    compare_function_types(semantic_model, &call_function, func, &call_expr)
+                        .unwrap_or(false)
+                }) {
+                    has_match = true;
+                }
+
+                // 无论是否匹配, 都需要将真实的定义添加到结果中
+                // 如果存在原始定义, 则优先使用原始定义
+                let origin = extract_semantic_decl_from_signature(compilation, &signature_id);
+                if let Some(origin) = origin {
+                    result.insert(0, origin);
+                } else {
+                    result.insert(0, decl.clone());
+                }
+            }
+            _ => continue,
         }
     }
 
@@ -48,58 +77,6 @@ pub fn find_matching_function_definitions(
     }
 }
 
-fn process_member_function_type(
-    semantic_model: &SemanticModel,
-    compilation: &LuaCompilation,
-    call_function: &Arc<LuaFunctionType>,
-    call_expr: &LuaCallExpr,
-    decl: &LuaSemanticDeclId,
-    member_id: &LuaMemberId,
-    result: &mut Vec<LuaSemanticDeclId>,
-    has_match: &mut bool,
-) -> bool {
-    let typ = semantic_model.get_type(member_id.clone().into());
-    match typ {
-        LuaType::DocFunction(func) => {
-            if compare_function_types(semantic_model, call_function, &func, call_expr)
-                .unwrap_or(false)
-            {
-                result.push(decl.clone());
-                *has_match = true;
-            }
-        }
-        LuaType::Signature(signature_id) => {
-            let signature = match semantic_model
-                .get_db()
-                .get_signature_index()
-                .get(&signature_id)
-            {
-                Some(sig) => sig,
-                None => return false,
-            };
-            let functions = get_signature_functions(signature);
-
-            if functions.iter().any(|func| {
-                compare_function_types(semantic_model, call_function, func, call_expr)
-                    .unwrap_or(false)
-            }) {
-                *has_match = true;
-            }
-
-            // 无论是否匹配，都需要将真实的定义添加到结果中
-            // 如果存在原始定义，则优先使用原始定义
-            let origin = extract_semantic_decl_from_signature(compilation, &signature_id);
-            if let Some(origin) = origin {
-                result.insert(0, origin);
-            } else {
-                result.insert(0, decl.clone());
-            }
-        }
-        _ => return false,
-    }
-    true
-}
-
 pub fn find_function_call_origin(
     semantic_model: &SemanticModel,
     compilation: &LuaCompilation,
@@ -205,28 +182,99 @@ fn get_call_function(
 ) -> Option<Arc<LuaFunctionType>> {
     let func = semantic_model.infer_call_expr_func(call_expr.clone(), None);
     if let Some(func) = func {
-        let call_expr_args_count = call_expr.get_args_count();
-        if let Some(mut call_expr_args_count) = call_expr_args_count {
-            let mut func_params_count = func.get_params().len();
-            if !func.is_colon_define() && call_expr.is_colon_call() {
-                // 不是冒号定义的函数, 但是是冒号调用
-                call_expr_args_count += 1;
+        if check_params_count_is_match(semantic_model, &func, call_expr.clone()).unwrap_or(false) {
+            return Some(func);
+        }
+    }
+    None
+}
+
+fn check_params_count_is_match(
+    semantic_model: &SemanticModel,
+    call_function: &LuaFunctionType,
+    call_expr: LuaCallExpr,
+) -> Option<bool> {
+    let mut fake_params = call_function.get_params().to_vec();
+    let call_args = call_expr.get_args_list()?.get_args().collect::<Vec<_>>();
+    let mut call_args_count = call_args.len();
+    let colon_call = call_expr.is_colon_call();
+    let colon_define = call_function.is_colon_define();
+    match (colon_call, colon_define) {
+        (true, true) | (false, false) => {}
+        (false, true) => {
+            fake_params.insert(0, ("self".to_string(), Some(LuaType::SelfInfer)));
+        }
+        (true, false) => {
+            call_args_count += 1;
+        }
+    }
+    if call_args_count < fake_params.len() {
+        // 调用参数包含 `...`
+        for arg in call_args.iter() {
+            if let LuaExpr::LiteralExpr(literal_expr) = arg {
+                if let Some(literal_token) = literal_expr.get_literal() {
+                    if let LuaLiteralToken::Dots(_) = literal_token {
+                        return Some(true);
+                    }
+                }
             }
-            // 如果参数有可空参数, 则需要减去
-            for (_, param_type) in func.get_params().iter() {
-                if let Some(param_type) = param_type {
-                    if param_type.is_optional() {
-                        func_params_count -= 1;
+        }
+        // 对调用参数的最后一个参数进行特殊处理
+        if let Some(last_arg) = call_args.last() {
+            if let Ok(LuaType::Variadic(variadic)) = semantic_model.infer_expr(last_arg.clone()) {
+                let len = match variadic.get_max_len() {
+                    Some(len) => len,
+                    None => {
+                        return Some(true);
                     }
+                };
+                call_args_count = call_args_count + len as usize - 1;
+                if call_args_count >= fake_params.len() {
+                    return Some(true);
+                }
+            }
+        }
+
+        for i in call_args_count..fake_params.len() {
+            let param_info = fake_params.get(i)?;
+            if param_info.0 == "..." {
+                return Some(true);
+            }
+
+            let typ = param_info.1.clone();
+            if let Some(typ) = typ {
+                if !typ.is_optional() {
+                    return Some(false);
                 }
             }
+        }
+    } else if call_args_count > fake_params.len() {
+        // 参数定义中最后一个参数是 `...`
+        if fake_params.last().map_or(false, |(name, typ)| {
+            name == "..."
+                || if let Some(typ) = typ {
+                    typ.is_variadic()
+                } else {
+                    false
+                }
+        }) {
+            return Some(true);
+        }
 
-            if call_expr_args_count == func_params_count {
-                return Some(func);
+        let mut adjusted_index = 0;
+        if colon_call != colon_define {
+            adjusted_index = if colon_define && !colon_call { -1 } else { 1 };
+        }
+
+        for (i, _) in call_args.iter().enumerate() {
+            let param_index = i as isize + adjusted_index;
+            if param_index < 0 || param_index < fake_params.len() as isize {
+                continue;
             }
+            return Some(false);
         }
     }
-    None
+    Some(true)
 }
 
 fn get_signature_functions(signature: &LuaSignature) -> Vec<Arc<LuaFunctionType>> {

crates/emmylua_ls/src/handlers/test/definition_test.rs

@@ -430,4 +430,47 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_goto_variable_param() {
+        let mut ws = ProviderVirtualWorkspace::new();
+        ws.def_file(
+            "a.lua",
+            r#"
+                ---@class Observable<T>
+
+                ---test
+                local function zipLatest(...)
+                end
+                return zipLatest
+            "#,
+        );
+        ws.def_file(
+            "b.lua",
+            r#"
+            local export = {}
+            local zipLatest = require('a')
+            export.zipLatest = zipLatest
+            return export
+            "#,
+        );
+        let result = ws
+            .check_definition(
+                r#"
+                local zipLatest = require('b').zipLatest
+                zipLatest<??>()
+            "#,
+            )
+            .unwrap();
+        match result {
+            GotoDefinitionResponse::Array(array) => {
+                assert_eq!(array.len(), 1);
+                let location = &array[0];
+                assert_eq!(location.uri.path().as_str().ends_with("a.lua"), true);
+            }
+            _ => {
+                panic!("expect array");
+            }
+        }
+    }
 }