Fix #594

Author: CppCXY

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

@@ -1,6 +1,6 @@
 #[cfg(test)]
 mod test {
-    use crate::{DiagnosticCode, VirtualWorkspace};
+    use crate::{DiagnosticCode, EmmyrcLuaVersion, VirtualWorkspace};
 
     #[test]
     fn test_unpack() {
@@ -42,4 +42,22 @@ mod test {
         "#,
         ));
     }
+
+    #[test]
+    fn test_issue_594() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+        let mut emmyrc = ws.get_emmyrc();
+        emmyrc.runtime.version = EmmyrcLuaVersion::Lua51;
+        ws.analysis.update_config(emmyrc.into());
+        assert!(ws.check_code_for(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+        --- @type string[]
+        local s = {}
+
+        --- @type string[]
+        local s2 = { 'a', unpack(s) }
+        "#,
+        ));
+    }
 }

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

@@ -1,3 +1,5 @@
+use std::ops::Deref;
+
 use emmylua_parser::{
     LuaAssignStat, LuaAst, LuaAstNode, LuaAstToken, LuaExpr, LuaIndexExpr, LuaLocalStat,
     LuaNameExpr, LuaTableExpr, LuaVarExpr,
@@ -6,7 +8,7 @@ use rowan::TextRange;
 
 use crate::{
     infer_index_expr, DiagnosticCode, LuaDeclExtra, LuaDeclId, LuaMemberKey, LuaSemanticDeclId,
-    LuaType, SemanticDeclLevel, SemanticModel, TypeCheckFailReason, TypeCheckResult,
+    LuaType, SemanticDeclLevel, SemanticModel, TypeCheckFailReason, TypeCheckResult, VariadicType,
 };
 
 use super::{humanize_lint_type, Checker, DiagnosticContext};
@@ -252,15 +254,14 @@ fn check_table_expr_content(
         // 位于的最后的 TableFieldValue 允许接受函数调用返回的多值, 而且返回的值必然会从下标 1 开始覆盖掉所有索引字段.
         if field.is_value_field() && idx == fields.len() - 1 {
             match &expr_type {
-                LuaType::Variadic(_) => {
-                    // 解开可变参数
-                    let expr_types =
-                        semantic_model.infer_expr_list_types(&vec![value_expr.clone()], None);
+                LuaType::Variadic(variadic) => {
                     if let Some(result) = check_table_last_variadic_type(
                         context,
                         semantic_model,
                         table_type,
-                        &expr_types,
+                        idx,
+                        &variadic,
+                        field.get_range(),
                     ) {
                         has_diagnostic = has_diagnostic || result;
                     }
@@ -319,38 +320,40 @@ fn check_table_last_variadic_type(
     context: &mut DiagnosticContext,
     semantic_model: &SemanticModel,
     table_type: &LuaType,
-    expr_types: &[(LuaType, TextRange)],
+    idx: usize,
+    value_variadic: &VariadicType,
+    range: TextRange,
 ) -> Option<bool> {
-    let mut has_diagnostic = false;
-
-    for (idx, (expr_type, range)) in expr_types.iter().enumerate() {
-        // 此时的值必然是从下标 1 开始递增的
-        let member_key = LuaMemberKey::Integer(idx as i64 + 1);
+    // test max 10
+    for offset in idx..(idx + 10) {
+        let member_key = LuaMemberKey::Integer((idx + offset) as i64 + 1);
         let source_type = semantic_model
             .infer_member_type(&table_type, &member_key)
             .ok()?;
+        match source_type {
+            LuaType::Variadic(source_variadic) => {
+                return Some(source_variadic.deref() != value_variadic)
+            }
+            _ => {
+                let expr_type = value_variadic.get_type(offset)?;
 
-        let expr_type = if let LuaType::Variadic(variadic) = expr_type {
-            let Some(typ) = variadic.get_type(idx) else {
-                continue;
-            };
-            typ.clone()
-        } else {
-            expr_type.clone()
-        };
-
-        if let Some(result) = check_assign_type_mismatch(
-            context,
-            semantic_model,
-            *range,
-            Some(&source_type),
-            &expr_type,
-            false,
-        ) {
-            has_diagnostic = has_diagnostic || result;
+                if let Some(result) = check_assign_type_mismatch(
+                    context,
+                    semantic_model,
+                    range,
+                    Some(&source_type),
+                    &expr_type,
+                    false,
+                ) {
+                    if result {
+                        return Some(true);
+                    }
+                }
+            }
         }
     }
-    Some(has_diagnostic)
+
+    Some(false)
 }
 
 fn check_assign_type_mismatch(

crates/emmylua_code_analysis/src/semantic/infer/infer_table.rs

@@ -6,6 +6,7 @@ use emmylua_parser::{
 };
 
 use crate::{
+    check_type_compact,
     db_index::{DbIndex, LuaType},
     infer_call_expr_func, infer_expr, InferGuard, LuaArrayType, LuaDeclId, LuaInferCache,
     LuaMemberId, LuaTupleStatus, LuaTupleType, LuaUnionType, TypeOps, VariadicType,
@@ -75,6 +76,42 @@ fn infer_table_tuple_or_array(
         }
     }
 
+    if let Some(last_field) = fields.last() {
+        let last_value_expr = last_field.get_value_expr().ok_or(InferFailReason::None)?;
+        let last_expr_type = infer_expr(db, cache, last_value_expr)?;
+        match last_expr_type {
+            LuaType::Variadic(multi) => match &multi.deref() {
+                VariadicType::Base(base) => {
+                    let non_nil_base = TypeOps::Remove.apply(db, base, &LuaType::Nil);
+                    if fields.len() <= 1 {
+                        return Ok(LuaType::Array(
+                            LuaArrayType::from_base_type(non_nil_base).into(),
+                        ));
+                    }
+                    let len = fields.len() - 1;
+                    let mut all_can_accept_base = true;
+                    for i in 0..len {
+                        let field = fields.get(i).ok_or(InferFailReason::None)?;
+                        let value_expr = field.get_value_expr().ok_or(InferFailReason::None)?;
+                        let typ = infer_expr(db, cache, value_expr)?;
+                        if check_type_compact(db, &non_nil_base, &typ).is_err() {
+                            all_can_accept_base = false;
+                            break;
+                        }
+                    }
+
+                    if all_can_accept_base {
+                        return Ok(LuaType::Array(
+                            LuaArrayType::from_base_type(non_nil_base).into(),
+                        ));
+                    }
+                }
+                _ => {}
+            },
+            _ => {}
+        };
+    }
+
     let mut types = Vec::new();
     for field in fields {
         let value_expr = field.get_value_expr().ok_or(InferFailReason::None)?;