update diagnostic MissingFields

Author: xuhuanzy

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

@@ -247,7 +247,7 @@ where
 
     if display_types.len() == 1 {
         if has_function && has_nil {
-            format!("{}?", type_str)
+            format!("({})?", type_str)
         } else {
             format!("{}{}", type_str, if has_nil { "?" } else { "" })
         }

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

@@ -29,7 +29,33 @@ fn check_table_expr(
     type_cache: &mut HashMap<LuaType, HashSet<String>>,
 ) -> Option<()> {
     let db = context.db;
-    let table_type = semantic_model.infer_table_should_be(expr.clone())?;
+
+    let table_type = match semantic_model.infer_table_should_be(expr.clone())? {
+        LuaType::Union(union) => {
+            let mut set = HashSet::new();
+            for ty in union.get_types() {
+                match ty {
+                    LuaType::Ref(_)
+                    | LuaType::Object(_)
+                    | LuaType::Generic(_)
+                    | LuaType::Intersection(_) => {
+                        set.insert(ty.clone());
+                    }
+                    LuaType::Table | LuaType::Userdata => {
+                        return Some(());
+                    }
+                    _ => {}
+                }
+            }
+            match set.len() {
+                1 => set.into_iter().next()?.clone(),
+                _ => {
+                    return Some(());
+                }
+            }
+        }
+        table_type => table_type,
+    };
 
     let current_fields = expr
         .get_fields()

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

@@ -78,13 +78,13 @@ pub fn check_file(context: &mut DiagnosticContext, semantic_model: &SemanticMode
     run_check::<local_const_reassign::LocalConstReassignChecker>(context, semantic_model);
     run_check::<discard_returns::DiscardReturnsChecker>(context, semantic_model);
     run_check::<await_in_sync::AwaitInSyncChecker>(context, semantic_model);
+    run_check::<missing_fields::MissingFieldsChecker>(context, semantic_model);
     run_check::<param_type_check::ParamTypeCheckChecker>(context, semantic_model);
     run_check::<need_check_nil::NeedCheckNilChecker>(context, semantic_model);
     run_check::<code_style_check::CodeStyleCheckChecker>(context, semantic_model);
     run_check::<return_type_mismatch::ReturnTypeMismatch>(context, semantic_model);
     run_check::<undefined_doc_param::UndefinedDocParamChecker>(context, semantic_model);
     run_check::<redefined_local::RedefinedLocalChecker>(context, semantic_model);
-    run_check::<missing_fields::MissingFieldsChecker>(context, semantic_model);
     run_check::<check_field::CheckFieldChecker>(context, semantic_model);
     run_check::<circle_doc_class::CircleDocClassChecker>(context, semantic_model);
     run_check::<incomplete_signature_doc::IncompleteSignatureDocChecker>(context, semantic_model);

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

@@ -1253,4 +1253,28 @@ mod test {
             "#
         ));
     }
+
+    #[test]
+    fn test_generic_union_type() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+                ---@class Params<T>
+                ---@field next fun(value: T)
+                ---@field error? fun(error: any)
+
+                ---@generic T
+                ---@param params fun(value: T) | Params<T>
+                function test(params)
+                end
+
+            "#,
+        );
+        assert!(!ws.check_code_for(
+            DiagnosticCode::ParamTypeNotMatch,
+            r#"
+                test({})
+            "#
+        ));
+    }
 }

crates/emmylua_code_analysis/src/semantic/type_check/generic_type.rs

@@ -17,9 +17,7 @@ pub fn check_generic_type_compact(
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
     // 不检查尚未实例化的泛型类
-    if source_generic.contain_tpl() {
-        return Ok(());
-    }
+    let is_tpl = source_generic.contain_tpl();
 
     let source_base_id = source_generic.get_base_type_id();
     let type_decl = db
@@ -41,24 +39,34 @@ pub fn check_generic_type_compact(
     }
 
     match compact_type {
-        LuaType::Generic(compact_generic) => check_generic_type_compact_generic(
-            db,
-            source_generic,
-            compact_generic,
-            check_guard.next_level()?,
-        ),
+        LuaType::Generic(compact_generic) => {
+            if is_tpl {
+                return Ok(());
+            }
+            check_generic_type_compact_generic(
+                db,
+                source_generic,
+                compact_generic,
+                check_guard.next_level()?,
+            )
+        }
         LuaType::TableConst(range) => check_generic_type_compact_table(
             db,
             source_generic,
             LuaMemberOwner::Element(range.clone()),
             check_guard.next_level()?,
         ),
-        LuaType::Ref(_) | LuaType::Def(_) => check_ref_type_compact(
-            db,
-            &source_generic.get_base_type_id(),
-            compact_type,
-            check_guard.next_level()?,
-        ),
+        LuaType::Ref(_) | LuaType::Def(_) => {
+            if is_tpl {
+                return Ok(());
+            }
+            check_ref_type_compact(
+                db,
+                &source_generic.get_base_type_id(),
+                compact_type,
+                check_guard.next_level()?,
+            )
+        }
         _ => Err(TypeCheckFailReason::TypeNotMatch),
     }
 }