fix UnResolveCallClosureParams & UnResolveClosureReturn

Author: xuhuanzy

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/mod.rs

@@ -19,7 +19,7 @@ use resolve::{
     try_resolve_module_ref, try_resolve_return_point, try_resolve_table_field,
 };
 use resolve_closure::{
-    try_resolve_closure_params, try_resolve_closure_parent_params, try_resolve_closure_return,
+    try_resolve_call_closure_params, try_resolve_closure_parent_params, try_resolve_closure_return,
 };
 
 use super::{infer_manager::InferCacheManager, lua::LuaReturnPoint, AnalyzeContext};
@@ -179,7 +179,7 @@ fn try_resolve(
                         try_resolve_return_point(db, cache, un_resolve_return)
                     }
                     UnResolve::ClosureParams(un_resolve_closure_params) => {
-                        try_resolve_closure_params(db, cache, un_resolve_closure_params)
+                        try_resolve_call_closure_params(db, cache, un_resolve_closure_params)
                     }
                     UnResolve::ClosureReturn(un_resolve_closure_return) => {
                         try_resolve_closure_return(db, cache, un_resolve_closure_return)

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve_closure.rs

@@ -3,9 +3,9 @@ use std::sync::Arc;
 use emmylua_parser::{LuaAstNode, LuaIndexMemberExpr, LuaTableExpr, LuaVarExpr};
 
 use crate::{
-    infer_call_expr_func, infer_expr, infer_table_should_be, DbIndex, InferFailReason, InferGuard,
-    LuaDocParamInfo, LuaDocReturnInfo, LuaFunctionType, LuaInferCache, LuaSignature, LuaType,
-    LuaUnionType, SignatureReturnStatus, TypeOps,
+    get_real_type, infer_call_expr_func, infer_expr, infer_table_should_be, DbIndex,
+    InferFailReason, InferGuard, LuaDocParamInfo, LuaDocReturnInfo, LuaFunctionType, LuaInferCache,
+    LuaSignature, LuaType, LuaUnionType, SignatureReturnStatus, TypeOps,
 };
 
 use super::{
@@ -14,7 +14,7 @@ use super::{
     UnResolveParentClosureParams, UnResolveReturn,
 };
 
-pub fn try_resolve_closure_params(
+pub fn try_resolve_call_closure_params(
     db: &mut DbIndex,
     cache: &mut LuaInferCache,
     closure_params: &mut UnResolveCallClosureParams,
@@ -50,21 +50,22 @@ pub fn try_resolve_closure_params(
         _ => {}
     }
 
-    let is_async;
-    let expr_closure_params = if let Some(param_type) = call_doc_func.get_params().get(param_idx) {
-        match &param_type.1 {
-            Some(LuaType::DocFunction(func)) => {
-                is_async = func.is_async();
-                func.get_params()
-            }
-            Some(LuaType::Union(union_types)) => {
+    let (is_async, params_to_insert) = if let Some(param_type) =
+        call_doc_func.get_params().get(param_idx)
+    {
+        let Some(param_type) = get_real_type(db, &param_type.1.as_ref().unwrap_or(&LuaType::Any))
+        else {
+            return Ok(());
+        };
+        match param_type {
+            LuaType::DocFunction(func) => (func.is_async(), func.get_params().to_vec()),
+            LuaType::Union(union_types) => {
                 if let Some(LuaType::DocFunction(func)) = union_types
                     .get_types()
                     .iter()
                     .find(|typ| matches!(typ, LuaType::DocFunction(_)))
                 {
-                    is_async = func.is_async();
-                    func.get_params()
+                    (func.is_async(), func.get_params().to_vec())
                 } else {
                     return Ok(());
                 }
@@ -81,7 +82,7 @@ pub fn try_resolve_closure_params(
         .ok_or(InferFailReason::None)?;
 
     let signature_params = &mut signature.param_docs;
-    for (idx, (name, type_ref)) in expr_closure_params.iter().enumerate() {
+    for (idx, (name, type_ref)) in params_to_insert.iter().enumerate() {
         if signature_params.contains_key(&idx) {
             continue;
         }
@@ -136,8 +137,12 @@ pub fn try_resolve_closure_return(
     }
 
     let ret_type = if let Some(param_type) = call_doc_func.get_params().get(param_idx) {
-        if let Some(LuaType::DocFunction(func)) = &param_type.1 {
-            func.get_ret()
+        let Some(param_type) = get_real_type(db, &param_type.1.as_ref().unwrap_or(&LuaType::Any))
+        else {
+            return Ok(());
+        };
+        if let LuaType::DocFunction(func) = param_type {
+            func.get_ret().clone()
         } else {
             return Ok(());
         }

crates/emmylua_code_analysis/src/compilation/test/closure_param_infer_test.rs

@@ -463,4 +463,27 @@ mod test {
         let expected = ws.ty("Trigger");
         assert_eq!(ws.humanize_type(ty), ws.humanize_type(expected));
     }
+
+    #[test]
+    fn test_param_function_is_alias() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@class LocalTimer
+            ---@alias LocalTimer.OnTimer fun(timer: LocalTimer, count: integer, ...: any)
+
+            ---@param on_timer LocalTimer.OnTimer
+            ---@return LocalTimer
+            function loop_count(on_timer)
+            end
+
+            loop_count(function(timer, count)
+                A = timer
+            end)
+            "#,
+        );
+        let ty = ws.expr_ty("A");
+        let expected = ws.ty("LocalTimer");
+        assert_eq!(ws.humanize_type(ty), ws.humanize_type(expected));
+    }
 }

crates/emmylua_code_analysis/src/db_index/type/mod.rs

@@ -15,6 +15,7 @@ pub use type_decl::{
 pub use type_ops::TypeOps;
 pub use type_owner::{LuaTypeCache, LuaTypeOwner};
 pub use types::*;
+pub use type_ops::get_real_type;
 
 #[derive(Debug)]
 pub struct LuaTypeIndex {

crates/emmylua_code_analysis/src/db_index/type/type_ops/mod.rs

@@ -48,29 +48,29 @@ impl TypeOps {
     }
 }
 
-pub fn get_real_type<'a>(db: &'a DbIndex, compact_type: &'a LuaType) -> Option<&'a LuaType> {
-    get_real_type_with_depth(db, compact_type, 0)
+pub fn get_real_type<'a>(db: &'a DbIndex, typ: &'a LuaType) -> Option<&'a LuaType> {
+    get_real_type_with_depth(db, typ, 0)
 }
 
 fn get_real_type_with_depth<'a>(
     db: &'a DbIndex,
-    compact_type: &'a LuaType,
+    typ: &'a LuaType,
     depth: u32,
 ) -> Option<&'a LuaType> {
     const MAX_RECURSION_DEPTH: u32 = 100;
 
     if depth >= MAX_RECURSION_DEPTH {
-        return Some(compact_type);
+        return Some(typ);
     }
 
-    match compact_type {
+    match typ {
         LuaType::Ref(type_decl_id) => {
             let type_decl = db.get_type_index().get_type_decl(type_decl_id)?;
             if type_decl.is_alias() {
                 return get_real_type_with_depth(db, type_decl.get_alias_ref()?, depth + 1);
             }
-            Some(compact_type)
+            Some(typ)
         }
-        _ => Some(compact_type),
+        _ => Some(typ),
     }
 }