diagnostic: 增强参数与返回值的表检查, 当表字段不匹配时反向抑制参数与返回值检查

Author: xuhuanzy

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

@@ -113,9 +113,9 @@ fn check_name_expr(
         check_table_expr(
             context,
             semantic_model,
+            &expr,
             source_type.as_ref(),
             Some(&value_type),
-            &expr,
         );
     }
 
@@ -149,9 +149,9 @@ fn check_index_expr(
         check_table_expr(
             context,
             semantic_model,
+            &expr,
             source_type.as_ref(),
             Some(&value_type),
-            &expr,
         );
     }
     Some(())
@@ -192,35 +192,35 @@ fn check_local_stat(
             check_table_expr(
                 context,
                 semantic_model,
+                &expr,
                 Some(&var_type),
                 Some(&value_type),
-                &expr,
             );
         }
     }
     Some(())
 }
 
-fn check_table_expr(
+pub fn check_table_expr(
     context: &mut DiagnosticContext,
     semantic_model: &SemanticModel,
+    table_expr: &LuaExpr,
     table_type: Option<&LuaType>, // 记录的类型
     expr_type: Option<&LuaType>,  // 实际表达式推导出的类型
-    table_expr: &LuaExpr,
-) -> Option<()> {
+) -> Option<bool> {
     // 需要进行一些过滤
     if table_type == expr_type {
-        return Some(());
+        return Some(false);
     }
     let table_type = table_type?;
     match table_type {
-        LuaType::Def(_) => return Some(()),
+        LuaType::Def(_) => return Some(false),
         _ => {}
     }
     if let Some(table_expr) = LuaTableExpr::cast(table_expr.syntax().clone()) {
-        check_table_expr_content(context, semantic_model, table_type, &table_expr);
+        return check_table_expr_content(context, semantic_model, table_type, &table_expr);
     }
-    Some(())
+    Some(false)
 }
 
 // 处理 value_expr 是 TableExpr 的情况, 但不会处理 `local a = { x = 1 }, local v = a`
@@ -229,16 +229,17 @@ fn check_table_expr_content(
     semantic_model: &SemanticModel,
     table_type: &LuaType,
     table_expr: &LuaTableExpr,
-) -> Option<()> {
+) -> Option<bool> {
     const MAX_CHECK_COUNT: usize = 250;
     let mut check_count = 0;
+    let mut has_diagnostic = false;
 
     let fields = table_expr.get_fields().collect::<Vec<_>>();
 
     for (idx, field) in fields.iter().enumerate() {
         check_count += 1;
         if check_count > MAX_CHECK_COUNT {
-            return Some(());
+            return Some(has_diagnostic);
         }
         let Some(value_expr) = field.get_value_expr() else {
             continue;
@@ -255,12 +256,14 @@ fn check_table_expr_content(
                     // 解开可变参数
                     let expr_types =
                         semantic_model.infer_expr_list_types(&vec![value_expr.clone()], None);
-                    check_table_last_variadic_type(
+                    if let Some(result) = check_table_last_variadic_type(
                         context,
                         semantic_model,
                         table_type,
                         &expr_types,
-                    );
+                    ) {
+                        has_diagnostic = has_diagnostic || result;
+                    }
                     continue;
                 }
                 _ => {}
@@ -283,7 +286,11 @@ fn check_table_expr_content(
         if source_type.is_table() || source_type.is_custom_type() {
             if let Some(table_expr) = LuaTableExpr::cast(value_expr.syntax().clone()) {
                 // 检查子表
-                check_table_expr_content(context, semantic_model, &source_type, &table_expr);
+                if let Some(result) =
+                    check_table_expr_content(context, semantic_model, &source_type, &table_expr)
+                {
+                    has_diagnostic = has_diagnostic || result;
+                }
                 continue;
             }
         }
@@ -293,25 +300,29 @@ fn check_table_expr_content(
             _ => false,
         };
 
-        check_assign_type_mismatch(
+        if let Some(result) = check_assign_type_mismatch(
             context,
             semantic_model,
             field.get_range(),
             Some(&source_type),
             &expr_type,
             allow_nil,
-        );
+        ) {
+            has_diagnostic = has_diagnostic || result;
+        }
     }
 
-    Some(())
+    Some(has_diagnostic)
 }
 
 fn check_table_last_variadic_type(
     context: &mut DiagnosticContext,
     semantic_model: &SemanticModel,
     table_type: &LuaType,
     expr_types: &[(LuaType, TextRange)],
-) -> Option<()> {
+) -> 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);
@@ -328,16 +339,18 @@ fn check_table_last_variadic_type(
             expr_type.clone()
         };
 
-        check_assign_type_mismatch(
+        if let Some(result) = check_assign_type_mismatch(
             context,
             semantic_model,
             *range,
             Some(&source_type),
             &expr_type,
             false,
-        );
+        ) {
+            has_diagnostic = has_diagnostic || result;
+        }
     }
-    Some(())
+    Some(has_diagnostic)
 }
 
 fn check_assign_type_mismatch(
@@ -347,28 +360,28 @@ fn check_assign_type_mismatch(
     source_type: Option<&LuaType>,
     value_type: &LuaType,
     allow_nil: bool,
-) -> Option<()> {
+) -> Option<bool> {
     let source_type = source_type.unwrap_or(&LuaType::Any);
     // 如果一致, 则不进行类型检查
     if source_type == value_type {
-        return Some(());
+        return Some(false);
     }
 
     // 某些情况下我们应允许可空, 例如: boolean[]
     if allow_nil && value_type.is_nullable() {
-        return Some(());
+        return Some(false);
     }
 
     match (&source_type, &value_type) {
         // 如果源类型是定义类型, 则仅在目标类型是定义类型或引用类型时进行类型检查
         (LuaType::Def(_), LuaType::Def(_) | LuaType::Ref(_)) => {}
-        (LuaType::Def(_), _) => return Some(()),
+        (LuaType::Def(_), _) => return Some(false),
         // 此时检查交给 table_field
-        (LuaType::Ref(_) | LuaType::Tuple(_), LuaType::TableConst(_)) => return Some(()),
-        (LuaType::Nil, _) => return Some(()),
+        (LuaType::Ref(_) | LuaType::Tuple(_), LuaType::TableConst(_)) => return Some(false),
+        (LuaType::Nil, _) => return Some(false),
         (LuaType::Ref(_), LuaType::Instance(instance)) => {
             if instance.get_base().is_table() {
-                return Some(());
+                return Some(false);
             }
         }
         _ => {}
@@ -384,8 +397,9 @@ fn check_assign_type_mismatch(
             &value_type,
             result,
         );
+        return Some(true);
     }
-    Some(())
+    Some(false)
 }
 
 fn add_type_check_diagnostic(

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

@@ -2,16 +2,20 @@ use emmylua_parser::{LuaAst, LuaAstNode, LuaAstToken, LuaCallExpr, LuaExpr, LuaI
 use rowan::TextRange;
 
 use crate::{
-    humanize_type, DiagnosticCode, LuaSemanticDeclId, LuaType, RenderLevel, SemanticDeclLevel,
-    SemanticModel, TypeCheckFailReason, TypeCheckResult,
+    diagnostic::checker::assign_type_mismatch::check_table_expr, humanize_type, DiagnosticCode,
+    LuaSemanticDeclId, LuaType, RenderLevel, SemanticDeclLevel, SemanticModel, TypeCheckFailReason,
+    TypeCheckResult,
 };
 
 use super::{Checker, DiagnosticContext};
 
 pub struct ParamTypeCheckChecker;
 
 impl Checker for ParamTypeCheckChecker {
-    const CODES: &[DiagnosticCode] = &[DiagnosticCode::ParamTypeNotMatch];
+    const CODES: &[DiagnosticCode] = &[
+        DiagnosticCode::ParamTypeNotMatch,
+        DiagnosticCode::AssignTypeMismatch,
+    ];
 
     /// a simple implementation of param type check, later we will do better
     fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) {
@@ -85,6 +89,35 @@ fn check_call_expr(
             }
             let result = semantic_model.type_check(&check_type, arg_type);
             if !result.is_ok() {
+                // 这里执行了`AssignTypeMismatch`的检查
+                if arg_type.is_table() {
+                    let arg_expr_idx = match (colon_call, colon_define) {
+                        (true, false) => {
+                            if idx == 0 {
+                                continue;
+                            } else {
+                                idx - 1
+                            }
+                        }
+                        _ => idx,
+                    };
+
+                    if let Some(arg_expr) = arg_exprs.get(arg_expr_idx) {
+                        // 表字段已经报错了, 则不添加参数不匹配的诊断避免干扰
+                        if let Some(add_diagnostic) = check_table_expr(
+                            context,
+                            semantic_model,
+                            arg_expr,
+                            Some(&param_type),
+                            Some(arg_type),
+                        ) {
+                            if add_diagnostic {
+                                continue;
+                            }
+                        }
+                    }
+                }
+
                 try_add_diagnostic(
                     context,
                     semantic_model,

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

@@ -4,16 +4,20 @@ use emmylua_parser::{
 use rowan::{NodeOrToken, TextRange};
 
 use crate::{
-    humanize_type, DiagnosticCode, LuaSemanticDeclId, LuaSignatureId, LuaType, RenderLevel,
-    SemanticDeclLevel, SemanticModel, SignatureReturnStatus, TypeCheckFailReason, TypeCheckResult,
+    diagnostic::checker::assign_type_mismatch::check_table_expr, humanize_type, DiagnosticCode,
+    LuaSemanticDeclId, LuaSignatureId, LuaType, RenderLevel, SemanticDeclLevel, SemanticModel,
+    SignatureReturnStatus, TypeCheckFailReason, TypeCheckResult,
 };
 
 use super::{get_return_stats, Checker, DiagnosticContext};
 
 pub struct ReturnTypeMismatch;
 
 impl Checker for ReturnTypeMismatch {
-    const CODES: &[DiagnosticCode] = &[DiagnosticCode::ReturnTypeMismatch];
+    const CODES: &[DiagnosticCode] = &[
+        DiagnosticCode::ReturnTypeMismatch,
+        DiagnosticCode::AssignTypeMismatch,
+    ];
 
     fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) {
         let root = semantic_model.get_root().clone();
@@ -54,9 +58,9 @@ fn check_return_stat(
     return_type: &LuaType,
     return_stat: &LuaReturnStat,
 ) -> Option<()> {
+    let return_exprs = return_stat.get_expr_list().collect::<Vec<_>>();
     let (return_expr_types, return_expr_ranges) = {
-        let infos = semantic_model
-            .infer_expr_list_types(&return_stat.get_expr_list().collect::<Vec<_>>(), None);
+        let infos = semantic_model.infer_expr_list_types(&return_exprs, None);
         let mut return_expr_types = infos.iter().map(|(typ, _)| typ.clone()).collect::<Vec<_>>();
         // 解决 setmetatable 的返回值类型问题
         let setmetatable_index = has_setmetatable(semantic_model, return_stat);
@@ -87,6 +91,18 @@ fn check_return_stat(
 
                 let result = semantic_model.type_check(check_type, return_expr_type);
                 if !result.is_ok() {
+                    if return_expr_type.is_table() {
+                        if let Some(return_expr) = return_exprs.get(index) {
+                            check_table_expr(
+                                context,
+                                semantic_model,
+                                return_expr,
+                                Some(check_type),
+                                Some(return_expr_type),
+                            );
+                        }
+                    }
+
                     add_type_check_diagnostic(
                         context,
                         semantic_model,
@@ -112,6 +128,22 @@ fn check_return_stat(
             let return_expr_range = return_expr_ranges[0];
             let result = semantic_model.type_check(check_type, &return_expr_type);
             if !result.is_ok() {
+                if return_expr_type.is_table() {
+                    if let Some(return_expr) = return_exprs.get(0) {
+                        // 表字段已经报错了, 则不添加返回值不匹配的诊断避免干扰
+                        if let Some(add_diagnostic) = check_table_expr(
+                            context,
+                            semantic_model,
+                            return_expr,
+                            Some(return_type),
+                            Some(return_expr_type),
+                        ) {
+                            if add_diagnostic {
+                                return Some(());
+                            }
+                        }
+                    }
+                }
                 add_type_check_diagnostic(
                     context,
                     semantic_model,

crates/emmylua_code_analysis/src/diagnostic/test/assign_type_mismatch_test.rs

@@ -922,4 +922,30 @@ return t
         "#
         ));
     }
+
+    #[test]
+    fn test_param_tbale() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.check_code_for(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+                ---@class ability
+                ---@field t abilityType
+
+                ---@enum (key) abilityType
+                local abilityType = {
+                    passive = 1,
+                }
+
+                ---@param a ability
+                function test(a)
+
+                end
+
+                test({
+                    t = ""
+                })
+        "#
+        ));
+    }
 }