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,21 +192,21 @@ 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<()> {
     // 需要进行一些过滤
     if table_type == expr_type {

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,30 @@ 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) {
+                        check_table_expr(
+                            context,
+                            semantic_model,
+                            arg_expr,
+                            Some(&param_type),
+                            Some(arg_type),
+                        );
+                    }
+                }
+
                 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,17 @@ 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) {
+                        check_table_expr(
+                            context,
+                            semantic_model,
+                            return_expr,
+                            Some(return_type),
+                            Some(return_expr_type),
+                        );
+                    }
+                }
                 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 = ""
+                })
+        "#
+        ));
+    }
 }