refactor(diagnostic): table check

Author: xuhuanzy

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

@@ -17,7 +17,10 @@ use super::{
 pub struct AssignTypeMismatchChecker;
 
 impl Checker for AssignTypeMismatchChecker {
-    const CODES: &[DiagnosticCode] = &[DiagnosticCode::AssignTypeMismatch];
+    const CODES: &[DiagnosticCode] = &[
+        DiagnosticCode::AssignTypeMismatch,
+        DiagnosticCode::MissingFields,
+    ];
 
     fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) {
         for node in semantic_model.get_root().descendants::<LuaAst>() {

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

@@ -44,6 +44,7 @@ pub use render_type_mismatch::render_diagnostic_detail;
 use emmylua_parser::{
     LuaAstNode, LuaClosureExpr, LuaComment, LuaReturnStat, LuaStat, LuaSyntaxKind,
 };
+use hashbrown::HashMap;
 use lsp_types::{Diagnostic, DiagnosticSeverity, DiagnosticTag, NumberOrString};
 use rowan::TextRange;
 use std::sync::Arc;
@@ -93,7 +94,6 @@ pub fn check_file(context: &mut DiagnosticContext, semantic_model: &SemanticMode
         context,
         semantic_model,
     );
-    run_check::<table::missing_fields::MissingFieldsChecker>(context, semantic_model);
     run_check::<need_check_nil::NeedCheckNilChecker>(context, semantic_model);
     run_check::<undefined_doc_param::UndefinedDocParamChecker>(context, semantic_model);
     run_check::<redefined_local::RedefinedLocalChecker>(context, semantic_model);
@@ -145,6 +145,8 @@ pub struct DiagnosticContext<'a> {
     diagnostics: Vec<Diagnostic>,
     diagnostic_ranges: Vec<(TextRange, DiagnosticCode)>,
     pub config: Arc<LuaDiagnosticConfig>,
+    /// 必填字段缓存
+    required_fields_cache: HashMap<LuaType, Arc<Vec<String>>>,
 }
 
 impl<'a> DiagnosticContext<'a> {
@@ -155,6 +157,7 @@ impl<'a> DiagnosticContext<'a> {
             diagnostics: Vec::new(),
             diagnostic_ranges: Vec::new(),
             config,
+            required_fields_cache: HashMap::new(),
         }
     }
 

crates/emmylua_code_analysis/src/diagnostic/checker/param_check/mod.rs

@@ -15,6 +15,7 @@ impl Checker for ParamCheckChecker {
     const CODES: &[DiagnosticCode] = &[
         DiagnosticCode::ParamTypeMismatch,
         DiagnosticCode::AssignTypeMismatch,
+        DiagnosticCode::MissingFields,
         DiagnosticCode::MissingParameter,
         DiagnosticCode::RedundantParameter,
     ];
@@ -24,7 +25,8 @@ impl Checker for ParamCheckChecker {
         let redundant_enabled =
             context.is_checker_enable_by_code(&DiagnosticCode::RedundantParameter);
         let type_enabled = context.is_checker_enable_by_code(&DiagnosticCode::ParamTypeMismatch)
-            || context.is_checker_enable_by_code(&DiagnosticCode::AssignTypeMismatch);
+            || context.is_checker_enable_by_code(&DiagnosticCode::AssignTypeMismatch)
+            || context.is_checker_enable_by_code(&DiagnosticCode::MissingFields);
         let call_check_enabled = missing_enabled || redundant_enabled || type_enabled;
 
         let root = semantic_model.get_root().clone();

crates/emmylua_code_analysis/src/diagnostic/checker/param_check/param_type_mismatch.rs

@@ -109,6 +109,10 @@ pub(super) fn check_param_type_mismatch(
             )
             .is_handled()
         {
+            if current_candidates.len() == 1 {
+                arg_index += 1;
+                continue;
+            }
             return;
         }
 

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

@@ -19,6 +19,7 @@ impl Checker for ReturnTypeMismatch {
     const CODES: &[DiagnosticCode] = &[
         DiagnosticCode::ReturnTypeMismatch,
         DiagnosticCode::AssignTypeMismatch,
+        DiagnosticCode::MissingFields,
     ];
 
     fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) {
@@ -93,14 +94,16 @@ fn check_return_stat(
                 {
                     if return_expr_type.is_table()
                         && let Some(return_expr) = return_exprs.get(index)
-                    {
-                        check_table_assignment_diagnostics(
+                        && check_table_assignment_diagnostics(
                             context,
                             semantic_model,
                             return_expr,
                             return_expr_type,
                             check_type,
-                        );
+                        )
+                        .is_handled()
+                    {
+                        continue;
                     }
 
                     add_type_check_diagnostic(

crates/emmylua_code_analysis/src/diagnostic/checker/table/missing_fields.rs

@@ -1,24 +1,24 @@
-use emmylua_parser::{LuaAstNode, LuaExpr};
+use emmylua_parser::LuaExpr;
 
-use crate::{DiagnosticCode, LuaType, SemanticModel};
+use crate::{LuaType, SemanticModel};
 
 use super::DiagnosticContext;
 
-pub mod missing_fields;
 pub mod table_field_type_mismatch;
 pub mod table_type_mismatch;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum TableAssignmentOutcome {
     NotTable,
+    Fallback,
     Assignable,
     Reported,
     NoDiagnostic,
 }
 
 impl TableAssignmentOutcome {
     pub(crate) fn is_handled(self) -> bool {
-        matches!(self, Self::Assignable | Self::Reported)
+        matches!(self, Self::Assignable | Self::Reported | Self::NoDiagnostic)
     }
 }
 
@@ -33,12 +33,6 @@ pub(crate) fn check_table_assignment_diagnostics(
         return TableAssignmentOutcome::NotTable;
     };
 
-    if context
-        .has_diagnostic_codes_in_range(table_expr.get_range(), &[DiagnosticCode::MissingFields])
-    {
-        return TableAssignmentOutcome::Reported;
-    }
-
     table_type_mismatch::check_table_type_mismatch(
         context,
         semantic_model,