Fix test

Author: CppCXY

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

@@ -116,8 +116,7 @@ fn analyze_return(
     let parent = closure.get_parent::<LuaAst>()?;
     match &parent {
         LuaAst::LuaCallArgList(_) => {
-            analyze_lambda_returns(analyzer, signature_id, closure)?;
-            return Some(());
+            analyze_lambda_returns(analyzer, signature_id, closure);
         }
         _ => {}
     };

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

@@ -171,6 +171,14 @@ pub fn try_resolve_closure_return(
         return try_convert_to_func_body_infer(db, cache, closure_return);
     }
 
+    match signature.resolve_return {
+        SignatureReturnStatus::UnResolve => {}
+        SignatureReturnStatus::InferResolve => {
+            signature.return_docs.clear();
+        }
+        _ => return Some(true),
+    }
+
     signature.return_docs.push(LuaDocReturnInfo {
         name: None,
         type_ref: ret_type.clone(),

crates/emmylua_code_analysis/src/db_index/signature/signature.rs

@@ -113,9 +113,9 @@ impl LuaSignature {
 
     pub fn to_doc_func_type(&self) -> Arc<LuaFunctionType> {
         let params = self.get_type_params();
-        let return_types = self.get_return_type();
+        let return_type = self.get_return_type();
         let func_type =
-            LuaFunctionType::new(self.is_async, self.is_colon_define, params, return_types);
+            LuaFunctionType::new(self.is_async, self.is_colon_define, params, return_type);
         Arc::new(func_type)
     }
 
@@ -125,8 +125,8 @@ impl LuaSignature {
             params.remove(0);
         }
 
-        let return_types = self.get_return_type();
-        let func_type = LuaFunctionType::new(self.is_async, false, params, return_types);
+        let return_type = self.get_return_type();
+        let func_type = LuaFunctionType::new(self.is_async, false, params, return_type);
         Arc::new(func_type)
     }
 }

crates/emmylua_code_analysis/src/diagnostic/checker/check_param_count.rs

@@ -124,19 +124,6 @@ fn check_call_expr(
         }
         // 对调用参数的最后一个参数进行特殊处理
         if let Some(last_arg) = call_args.last() {
-            // 如果最后一个参数是函数调用的结果, 那么需要判断他的函数签名返回值是否包含可变参数
-            match last_arg {
-                LuaExpr::CallExpr(call_expr) => {
-                    if let Some(func) = semantic_model.infer_call_expr_func(call_expr.clone(), None)
-                    {
-                        if func.get_ret().is_variadic() {
-                            return Some(());
-                        }
-                    }
-                }
-                _ => {}
-            }
-
             if let Ok(LuaType::Variadic(variadic)) = semantic_model.infer_expr(last_arg.clone()) {
                 let len = match variadic.get_max_len() {
                     Some(len) => len,

crates/emmylua_code_analysis/src/diagnostic/checker/check_return_count.rs

@@ -71,13 +71,27 @@ fn check_missing_return(
         return None;
     }
 
-    // 如果包含可变参数, 则跳过检查最大值
-    // let skip_check_max =
-
     // 最小返回值数
     let min_expected_return_count = match &return_type {
-        LuaType::Variadic(variadic) => variadic.get_min_len()?,
+        LuaType::Variadic(variadic) => {
+            let min_len = variadic.get_min_len()?;
+            let mut real_min_len = min_len;
+            // 逆序检查
+            if min_len > 0 {
+                for i in (0..min_len).rev() {
+                    if let Some(ty) = variadic.get_type(i) {
+                        if ty.is_optional() {
+                            real_min_len -= 1;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+            real_min_len
+        }
         LuaType::Nil | LuaType::Any | LuaType::Unknown => 0,
+        _ if return_type.is_nullable() => 0,
         _ => 1,
     };
 
@@ -250,7 +264,8 @@ fn check_return_count(
 ) -> Option<()> {
     let max_expected_return_count = match return_type {
         LuaType::Variadic(variadic) => variadic.get_max_len(),
-        LuaType::Nil | LuaType::Any | LuaType::Unknown => Some(1),
+        LuaType::Any | LuaType::Unknown => Some(1),
+        LuaType::Nil => Some(0),
         _ => Some(1),
     };
 

crates/emmylua_code_analysis/src/diagnostic/checker/return_type_mismatch.rs

@@ -104,9 +104,15 @@ fn check_return_stat(
             }
         }
         _ => {
+            let mut check_type = return_type;
+            if return_type.is_self_infer() {
+                if let Some(self_type) = self_type {
+                    check_type = self_type;
+                }
+            }
             let return_expr_type = &return_expr_types[0];
             let return_expr_range = return_expr_ranges[0];
-            let result = semantic_model.type_check(return_type, &return_expr_type);
+            let result = semantic_model.type_check(check_type, &return_expr_type);
             if !result.is_ok() {
                 add_type_check_diagnostic(
                     context,

crates/emmylua_code_analysis/src/semantic/generic/instantiate_func_generic.rs

@@ -50,7 +50,7 @@ pub fn instantiate_func_generic(
         &arg_types,
         &call_expr.get_root(),
         &mut substitutor,
-    );
+    )?;
 
     if func.contain_self() {
         infer_self_type(db, cache, &call_expr, &mut substitutor)?;