fix analyzer Stat Variadic

Author: xuhuanzy

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

@@ -62,7 +62,9 @@ pub fn analyze_local_stat(analyzer: &mut LuaAnalyzer, local_stat: LuaLocalStat)
                         }
                     }
                 }
-
+                if let LuaType::Variadic(variadic) = expr_type {
+                    expr_type = variadic.as_ref().clone();
+                }
                 bind_type(
                     analyzer.db,
                     decl_id.into(),
@@ -104,10 +106,14 @@ pub fn analyze_local_stat(analyzer: &mut LuaAnalyzer, local_stat: LuaLocalStat)
                             let decl_id = LuaDeclId::new(analyzer.file_id, position);
                             let ret_type = multi.get_type(i - expr_count + 1);
                             if let Some(ty) = ret_type {
+                                let mut final_type = ty.clone();
+                                if let LuaType::Variadic(variadic) = final_type {
+                                    final_type = variadic.as_ref().clone();
+                                }
                                 bind_type(
                                     analyzer.db,
                                     decl_id.into(),
-                                    LuaTypeCache::InferType(ty.clone()),
+                                    LuaTypeCache::InferType(final_type),
                                 );
                             } else {
                                 analyzer.db.get_type_index_mut().bind_type(
@@ -298,22 +304,20 @@ pub fn analyze_assign_stat(analyzer: &mut LuaAnalyzer, assign_stat: LuaAssignSta
                 continue;
             }
         };
-
-        merge_type_owner_and_expr_type(analyzer, type_owner, &expr_type, 0);
+        assign_merge_type_owner_and_expr_type(analyzer, type_owner, &expr_type, 0);
     }
 
     // The complexity brought by multiple return values is too high
     if var_count > expr_count {
-        let last_expr = expr_list.last();
-        if let Some(last_expr) = last_expr.clone() {
+        if let Some(last_expr) = expr_list.last() {
             match analyzer.infer_expr(last_expr) {
                 Ok(last_expr_type) => {
                     if last_expr_type.is_multi_return() {
                         for i in expr_count..var_count {
                             let var = var_list.get(i)?;
                             let type_owner = get_var_owner(analyzer, var.clone());
                             set_index_expr_owner(analyzer, var.clone());
-                            merge_type_owner_and_expr_type(
+                            assign_merge_type_owner_and_expr_type(
                                 analyzer,
                                 type_owner,
                                 &last_expr_type,
@@ -344,7 +348,7 @@ pub fn analyze_assign_stat(analyzer: &mut LuaAnalyzer, assign_stat: LuaAssignSta
     Some(())
 }
 
-fn merge_type_owner_and_expr_type(
+fn assign_merge_type_owner_and_expr_type(
     analyzer: &mut LuaAnalyzer,
     type_owner: LuaTypeOwner,
     expr_type: &LuaType,
@@ -354,6 +358,12 @@ fn merge_type_owner_and_expr_type(
     if let LuaType::MuliReturn(multi) = expr_type {
         expr_type = multi.get_type(idx).unwrap_or(&LuaType::Nil).clone();
     }
+    match &expr_type {
+        LuaType::Variadic(variadic) => {
+            expr_type = variadic.as_ref().clone();
+        }
+        _ => {}
+    }
 
     bind_type(analyzer.db, type_owner, LuaTypeCache::InferType(expr_type));
 
@@ -483,7 +493,7 @@ fn special_assign_pattern(
 
     match analyzer.infer_expr(&right) {
         Ok(right_expr_type) => {
-            merge_type_owner_and_expr_type(analyzer, type_owner, &right_expr_type, 0);
+            assign_merge_type_owner_and_expr_type(analyzer, type_owner, &right_expr_type, 0);
         }
         Err(_) => return None,
     }

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

@@ -0,0 +1,58 @@
+#[cfg(test)]
+mod test {
+    use crate::{DiagnosticCode, VirtualWorkspace};
+
+    #[test]
+    fn test_1() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@return any ...
+        ---@return integer offset
+        local function unpack() end
+        a, b, c, d = unpack()
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("a"), ws.ty("any"));
+        assert_eq!(ws.expr_ty("b"), ws.ty("integer"));
+        assert_eq!(ws.expr_ty("c"), ws.ty("nil"));
+        assert_eq!(ws.expr_ty("d"), ws.ty("nil"));
+    }
+
+    #[test]
+    fn test_2() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@return integer offset
+        ---@return any ...
+        local function unpack() end
+        a, b, c, d = unpack()
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("a"), ws.ty("integer"));
+        assert_eq!(ws.expr_ty("b"), ws.ty("any"));
+        assert_eq!(ws.expr_ty("c"), ws.ty("any"));
+        assert_eq!(ws.expr_ty("d"), ws.ty("any"));
+    }
+
+    #[test]
+    fn test_3() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeNotMatch,
+            r#"
+                ---@return any ...
+                ---@return integer offset
+                local function unpack() end
+                
+                ---@param a nil|integer|'l'|'L'
+                local function test(a) end
+                local len = unpack()
+                test(len)
+        "#,
+        ));
+    }
+}

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

@@ -3,6 +3,7 @@ mod annotation_test;
 mod closure_generic;
 mod closure_param_infer_test;
 mod closure_return_test;
+mod decl_test;
 mod diagnostic_disable_test;
 mod flow;
 mod for_range_var_infer_test;

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

@@ -856,7 +856,7 @@ impl LuaMultiReturn {
                     let last_element_len = last_multi.get_len();
                     return match last_element_len {
                         Some(len) => Some(basic_len - 1 + len),
-                        None => None,
+                        None => Some(basic_len),
                     };
                 }
 

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

@@ -149,13 +149,7 @@ pub fn instantiate_doc_function(
                             }
                             SubstitutorValue::Type(ty) => new_returns.push(ty.clone()),
                             SubstitutorValue::MultiBase(base) => {
-                                if i + 1 == tpl_ret.len() {
-                                    new_returns.push(LuaType::Variadic(base.clone().into()));
-                                } else {
-                                    new_returns.push(LuaType::MuliReturn(
-                                        LuaMultiReturn::Base(base.clone()).into(),
-                                    ));
-                                }
+                                new_returns.push(LuaType::Variadic(base.clone().into()));
                             }
                         }
                     }