refactor complex type check, fix tuple check,

Fix #231

Author: CppCXY

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

@@ -16,3 +16,4 @@ mod overload_field;
 mod overload_test;
 mod static_cal_cmp;
 mod syntax_error_test;
+mod tuple_test;

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

@@ -0,0 +1,17 @@
+#[cfg(test)]
+mod tests {
+    use crate::{DiagnosticCode, VirtualWorkspace};
+
+    #[test]
+    fn test_issue_231() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+        assert!(ws.check_code_for(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+
+            --- @type [boolean, string]
+            local ret = { coroutine.resume(coroutine.create(function () end), ...) }
+            "#
+        ));
+    }
+}

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

@@ -266,6 +266,7 @@ impl LuaType {
         match self {
             LuaType::Nil | LuaType::Any | LuaType::Unknown => true,
             LuaType::Union(u) => u.types.iter().any(|t| t.is_optional()),
+            LuaType::Variadic(_) => true,
             _ => false,
         }
     }

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

@@ -167,6 +167,10 @@ fn handle_value_is_table_expr(
     let member_infos = semantic_model.infer_member_infos(&table_type)?;
     let fields = LuaTableExpr::cast(value_expr.syntax().clone())?.get_fields();
     for field in fields {
+        if field.is_value_field() {
+            continue;
+        }
+
         let field_key = field.get_field_key();
         if let Some(field_key) = field_key {
             let field_path_part = field_key.get_path_part();

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

@@ -141,7 +141,9 @@ fn add_type_check_diagnostic(
         Err(reason) => {
             let reason_message = match reason {
                 TypeCheckFailReason::TypeNotMatchWithReason(reason) => reason,
-                TypeCheckFailReason::TypeNotMatch => "".to_string(),
+                TypeCheckFailReason::TypeNotMatch | TypeCheckFailReason::DonotCheck => {
+                    "".to_string()
+                }
                 TypeCheckFailReason::TypeRecursion => "type recursion".to_string(),
             };
             context.add_diagnostic(

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

@@ -177,6 +177,7 @@ fn add_type_check_diagnostic(
                     None,
                 );
             }
+            TypeCheckFailReason::DonotCheck => {}
         },
     }
 }

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

@@ -359,7 +359,7 @@ fn unwrapp_return_type(
         }
 
         LuaType::MuliReturn(multi) => {
-            if is_last_expr(&call_expr) {
+            if is_last_call_expr(&call_expr) {
                 return Ok(return_type);
             }
 
@@ -369,7 +369,7 @@ fn unwrapp_return_type(
             };
         }
         LuaType::Variadic(inner) => {
-            if is_last_expr(&call_expr) {
+            if is_last_call_expr(&call_expr) {
                 return Ok(LuaType::MuliReturn(
                     LuaMultiReturn::Base(inner.deref().clone()).into(),
                 ));
@@ -407,21 +407,22 @@ fn is_need_wrap_instance(
     return !call_expr.get_range().contains(inst.value.start());
 }
 
-fn is_last_expr(call_expr: &LuaCallExpr) -> bool {
-    let parent = call_expr.syntax().parent();
-    if let Some(parent) = parent {
+fn is_last_call_expr(call_expr: &LuaCallExpr) -> bool {
+    let mut opt_parent = call_expr.syntax().parent();
+    while let Some(parent) = &opt_parent {
         match parent.kind().into() {
             LuaSyntaxKind::AssignStat
             | LuaSyntaxKind::LocalStat
             | LuaSyntaxKind::ReturnStat
             | LuaSyntaxKind::TableArrayExpr
             | LuaSyntaxKind::CallArgList => {
                 let next_expr = call_expr.syntax().next_sibling();
-                if next_expr.is_none() {
-                    return true;
-                }
+                return next_expr.is_none();
             }
-            _ => {}
+            LuaSyntaxKind::TableFieldValue => {
+                opt_parent = parent.parent();
+            }
+            _ => return false,
         }
     }
 

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

@@ -1,3 +1,5 @@
+use std::ops::Deref;
+
 use emmylua_parser::{
     LuaAssignStat, LuaAst, LuaAstNode, LuaCallArgList, LuaCallExpr, LuaExpr, LuaIndexMemberExpr,
     LuaLiteralToken, LuaLocalStat, LuaTableExpr, LuaTableField,
@@ -6,7 +8,7 @@ use emmylua_parser::{
 use crate::{
     db_index::{DbIndex, LuaType},
     infer_call_expr_func, infer_expr, InferGuard, LuaDeclId, LuaInferCache, LuaMemberId,
-    LuaTupleType,
+    LuaMultiReturn, LuaTupleType,
 };
 
 use super::{
@@ -44,29 +46,65 @@ fn infer_table_tuple_or_array(
         return Ok(LuaType::Array(first_type.into()));
     }
 
-    if let Some(last_field) = fields.last() {
-        let last_value_expr = last_field.get_value_expr().ok_or(InferFailReason::None)?;
-        if is_dots_expr(&last_value_expr).unwrap_or(false) {
-            let dots_type = infer_expr(db, cache, last_value_expr)?;
-            let typ = match &dots_type {
-                LuaType::MuliReturn(multi) => multi.get_type(0).unwrap_or(&LuaType::Unknown),
-                _ => &dots_type,
-            };
+    if let Some(first_field) = fields.first() {
+        let first_value_expr = first_field.get_value_expr().ok_or(InferFailReason::None)?;
 
-            return Ok(LuaType::Array(typ.clone().into()));
+        if is_dots_expr(&first_value_expr).unwrap_or(false) {
+            let first_expr_type = infer_expr(db, cache, first_value_expr)?;
+            match &first_expr_type {
+                LuaType::MuliReturn(multi) => match &multi.deref() {
+                    LuaMultiReturn::Base(base) => {
+                        return Ok(LuaType::Array(base.clone().into()));
+                    }
+                    LuaMultiReturn::Multi(tuple) => {
+                        return Ok(LuaType::Tuple(LuaTupleType::new(tuple.clone()).into()));
+                    }
+                },
+                LuaType::Variadic(base) => {
+                    return Ok(LuaType::Array(base.clone().into()));
+                }
+                _ => {
+                    return Ok(LuaType::Array(first_expr_type.into()));
+                }
+            };
         }
     }
 
     let mut types = Vec::new();
     for field in fields {
         let value_expr = field.get_value_expr().ok_or(InferFailReason::None)?;
         let typ = infer_expr(db, cache, value_expr)?;
-        types.push(typ);
+        match typ {
+            LuaType::MuliReturn(multi) => flatten_multi_into_tuple(&mut types, &multi),
+            _ => {
+                types.push(typ);
+            }
+        }
     }
 
     Ok(LuaType::Tuple(LuaTupleType::new(types).into()))
 }
 
+fn flatten_multi_into_tuple(tuple_list: &mut Vec<LuaType>, multi: &LuaMultiReturn) {
+    match multi {
+        LuaMultiReturn::Base(base) => {
+            tuple_list.push(LuaType::Variadic(base.clone().into()));
+        }
+        LuaMultiReturn::Multi(multi) => {
+            for typ in multi {
+                match typ {
+                    LuaType::MuliReturn(multi) => {
+                        flatten_multi_into_tuple(tuple_list, multi.deref());
+                    }
+                    _ => {
+                        tuple_list.push(typ.clone());
+                    }
+                }
+            }
+        }
+    }
+}
+
 fn is_dots_expr(expr: &LuaExpr) -> Option<bool> {
     if let LuaExpr::LiteralExpr(literal) = expr {
         match literal.get_literal()? {