refactor(diagnostic): param type check for all overloads

Author: xuhuanzy

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

@@ -2,8 +2,27 @@
 mod test {
     use std::{ops::Deref, sync::Arc};
 
+    use lsp_types::{Diagnostic, NumberOrString};
+    use tokio_util::sync::CancellationToken;
+
     use crate::{DiagnosticCode, VirtualWorkspace};
 
+    fn param_type_diagnostics(ws: &mut VirtualWorkspace, block_str: &str) -> Vec<Diagnostic> {
+        ws.analysis
+            .diagnostic
+            .enable_only(DiagnosticCode::ParamTypeMismatch);
+        let file_id = ws.def(block_str);
+        let code = Some(NumberOrString::String(
+            DiagnosticCode::ParamTypeMismatch.get_name().to_string(),
+        ));
+        ws.analysis
+            .diagnose_file(file_id, CancellationToken::new())
+            .unwrap_or_default()
+            .into_iter()
+            .filter(|diagnostic| diagnostic.code == code)
+            .collect()
+    }
+
     #[test]
     fn test_issue_216() {
         let mut ws = VirtualWorkspace::new();
@@ -41,6 +60,27 @@ mod test {
         ));
     }
 
+    #[test]
+    fn test_overload_param_type_mismatch_unions_failed_position() {
+        let mut ws = VirtualWorkspace::new();
+        let diagnostics = param_type_diagnostics(
+            &mut ws,
+            r#"
+            ---@type fun(name: "游戏-初始化") | fun(name: "游戏-开始")
+            local event
+            local bad ---@type boolean
+
+            event(bad)
+        "#,
+        );
+
+        assert_eq!(diagnostics.len(), 1);
+        let message = &diagnostics[0].message;
+        assert!(message.contains("boolean"), "{message}");
+        assert!(message.contains("游戏-初始化"), "{message}");
+        assert!(message.contains("游戏-开始"), "{message}");
+    }
+
     #[test]
     fn test_issue_75() {
         let mut ws = VirtualWorkspace::new_with_init_std_lib();
@@ -825,8 +865,9 @@ mod test {
 
                 ---@class (partial) D21.A
                 ---@field event fun(self: self, event: "游戏-初始化")
+                ---@field event fun(self: self, event: "游戏-开始")
 
-                ---@param p string
+                ---@param p boolean
                 local function test(p)
                     M:event(p)
                 end

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

@@ -1,12 +1,12 @@
 use std::{ops::Deref, sync::Arc};
 
-use emmylua_parser::{LuaAstNode, LuaAstToken, LuaCallExpr, LuaExpr, LuaIndexExpr};
+use emmylua_parser::{LuaAstNode, LuaAstToken, LuaCallExpr, LuaExpr};
 use hashbrown::HashSet;
 use rowan::TextRange;
 
 use crate::{
-    DbIndex, DocTypeInferContext, GenericTplId, LuaFunctionType, LuaSemanticDeclId, LuaType,
-    SemanticDeclLevel, SemanticModel, TypeOps, TypeSubstitutor, VariadicType, infer_doc_type,
+    DbIndex, DocTypeInferContext, GenericTplId, LuaFunctionType, LuaType, SemanticModel, TypeOps,
+    TypeSubstitutor, VariadicType, infer_doc_type,
 };
 
 use super::{TplContext, tpl_pattern_match_args};
@@ -59,7 +59,7 @@ pub fn build_call_constraint_context(
             params.insert(0, ("self".into(), Some(LuaType::SelfInfer)));
         }
         (true, false) => {
-            let source_type = infer_call_source_type(semantic_model, call_expr)?;
+            let source_type = semantic_model.infer_call_receiver_type(call_expr)?;
             args.insert(
                 0,
                 CallConstraintArg {
@@ -103,75 +103,6 @@ pub fn normalize_constraint_type(db: &DbIndex, ty: LuaType) -> LuaType {
     }
 }
 
-// 解析冒号调用时调用者的具体类型
-fn infer_call_source_type(
-    semantic_model: &SemanticModel,
-    call_expr: &LuaCallExpr,
-) -> Option<LuaType> {
-    match call_expr.get_prefix_expr()? {
-        LuaExpr::IndexExpr(index_expr) => {
-            let decl = semantic_model.find_decl(
-                index_expr.syntax().clone().into(),
-                SemanticDeclLevel::default(),
-            )?;
-
-            if let LuaSemanticDeclId::Member(member_id) = decl
-                && let Some(LuaSemanticDeclId::Member(member_id)) =
-                    semantic_model.get_member_origin_owner(member_id)
-            {
-                let root = semantic_model
-                    .get_db()
-                    .get_vfs()
-                    .get_syntax_tree(&member_id.file_id)?
-                    .get_red_root();
-                let cur_node = member_id.get_syntax_id().to_node_from_root(&root)?;
-                let index_expr = LuaIndexExpr::cast(cur_node)?;
-
-                return index_expr.get_prefix_expr().map(|prefix_expr| {
-                    semantic_model
-                        .infer_expr(prefix_expr.clone())
-                        .unwrap_or(LuaType::SelfInfer)
-                });
-            }
-
-            return if let Some(prefix_expr) = index_expr.get_prefix_expr() {
-                let expr_type = semantic_model
-                    .infer_expr(prefix_expr.clone())
-                    .unwrap_or(LuaType::SelfInfer);
-                Some(expr_type)
-            } else {
-                None
-            };
-        }
-        LuaExpr::NameExpr(name_expr) => {
-            let decl = semantic_model.find_decl(
-                name_expr.syntax().clone().into(),
-                SemanticDeclLevel::default(),
-            )?;
-            if let LuaSemanticDeclId::Member(member_id) = decl {
-                let root = semantic_model
-                    .get_db()
-                    .get_vfs()
-                    .get_syntax_tree(&member_id.file_id)?
-                    .get_red_root();
-                let cur_node = member_id.get_syntax_id().to_node_from_root(&root)?;
-                let index_expr = LuaIndexExpr::cast(cur_node)?;
-
-                return index_expr.get_prefix_expr().map(|prefix_expr| {
-                    semantic_model
-                        .infer_expr(prefix_expr.clone())
-                        .unwrap_or(LuaType::SelfInfer)
-                });
-            }
-
-            return None;
-        }
-        _ => {}
-    }
-
-    None
-}
-
 // 推推导每个实参类型
 fn get_arg_infos(
     semantic_model: &SemanticModel,

crates/emmylua_code_analysis/src/semantic/generic/call_constraint.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr, LuaSyntaxKind};
+use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr, LuaIndexExpr, LuaSyntaxKind};
 use hashbrown::HashSet;
 use rowan::TextRange;
 
@@ -11,13 +11,15 @@ use super::{
 use crate::semantic::overload_resolve::callable_accepts_args;
 use crate::{
     AsyncState, CacheEntry, DbIndex, InFiled, LuaFunctionType, LuaGenericType, LuaInstanceType,
-    LuaIntersectionType, LuaOperatorMetaMethod, LuaOperatorOwner, LuaSignature, LuaSignatureId,
-    LuaType, LuaTypeDeclId, LuaUnionType, TypeVisitTrait, VariadicType,
+    LuaIntersectionType, LuaOperatorMetaMethod, LuaOperatorOwner, LuaSemanticDeclId, LuaSignature,
+    LuaSignatureId, LuaType, LuaTypeDeclId, LuaUnionType, SemanticDeclLevel, TypeVisitTrait,
+    VariadicType,
 };
 use crate::{
     InferGuardRef,
     semantic::{
         generic::TypeSubstitutor, infer::narrow::get_type_at_call_expr_inline_cast,
+        infer_node_semantic_decl, member::find_member_origin_owner,
         overload_resolve::collect_callable_overload_groups,
     },
 };
@@ -838,6 +840,67 @@ fn signature_is_generic(
     }
 }
 
+/// 推断调用者的具体类型.
+pub fn infer_call_receiver_type(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    call_expr: &LuaCallExpr,
+) -> Option<LuaType> {
+    match call_expr.get_prefix_expr()? {
+        LuaExpr::IndexExpr(index_expr) => {
+            let decl = infer_node_semantic_decl(
+                db,
+                cache,
+                index_expr.syntax().clone(),
+                SemanticDeclLevel::default(),
+            )?;
+
+            if let LuaSemanticDeclId::Member(member_id) = decl
+                && let Some(LuaSemanticDeclId::Member(member_id)) =
+                    find_member_origin_owner(db, cache, member_id)
+            {
+                let root = db
+                    .get_vfs()
+                    .get_syntax_tree(&member_id.file_id)?
+                    .get_red_root();
+                let cur_node = member_id.get_syntax_id().to_node_from_root(&root)?;
+                let index_expr = LuaIndexExpr::cast(cur_node)?;
+
+                return index_expr.get_prefix_expr().map(|prefix_expr| {
+                    infer_expr(db, cache, prefix_expr).unwrap_or(LuaType::SelfInfer)
+                });
+            }
+
+            index_expr
+                .get_prefix_expr()
+                .map(|prefix_expr| infer_expr(db, cache, prefix_expr).unwrap_or(LuaType::SelfInfer))
+        }
+        LuaExpr::NameExpr(name_expr) => {
+            let decl = infer_node_semantic_decl(
+                db,
+                cache,
+                name_expr.syntax().clone(),
+                SemanticDeclLevel::default(),
+            )?;
+            if let LuaSemanticDeclId::Member(member_id) = decl {
+                let root = db
+                    .get_vfs()
+                    .get_syntax_tree(&member_id.file_id)?
+                    .get_red_root();
+                let cur_node = member_id.get_syntax_id().to_node_from_root(&root)?;
+                let index_expr = LuaIndexExpr::cast(cur_node)?;
+
+                return index_expr.get_prefix_expr().map(|prefix_expr| {
+                    infer_expr(db, cache, prefix_expr).unwrap_or(LuaType::SelfInfer)
+                });
+            }
+
+            None
+        }
+        _ => None,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{

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

@@ -17,7 +17,7 @@ use emmylua_parser::{
 };
 use infer_binary::infer_binary_expr;
 use infer_call::infer_call_expr;
-pub use infer_call::infer_call_expr_func;
+pub use infer_call::{infer_call_expr_func, infer_call_receiver_type};
 pub use infer_doc_type::{DocTypeInferContext, infer_doc_type};
 pub use infer_fail_reason::InferFailReason;
 pub use infer_index::infer_index_expr;

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

@@ -21,7 +21,7 @@ use emmylua_parser::{
     LuaSyntaxToken, LuaTableExpr,
 };
 pub use infer::infer_index_expr;
-use infer::{infer_bind_value_type, infer_expr_list_types};
+use infer::{infer_bind_value_type, infer_call_receiver_type, infer_expr_list_types};
 pub use infer::{infer_table_field_value_should_be, infer_table_should_be};
 use lsp_types::Uri;
 pub use member::LuaMemberInfo;
@@ -59,7 +59,10 @@ pub use infer::infer_param;
 pub(crate) use infer::try_infer_expr_for_index;
 pub(crate) use infer::{infer_expr, try_infer_expr_no_flow};
 use overload_resolve::resolve_signature;
-pub(crate) use overload_resolve::{callable_accepts_args, collect_callable_overload_groups};
+pub(crate) use overload_resolve::{
+    callable_accepts_args, collect_callable_overload_groups, get_func_param_type,
+    is_func_last_param_variadic,
+};
 pub use semantic_info::SemanticDeclLevel;
 pub use type_check::{TypeCheckFailReason, TypeCheckResult};
 
@@ -329,6 +332,10 @@ impl<'a> SemanticModel<'a> {
         find_member_origin_owner(self.db, &mut self.infer_cache.borrow_mut(), member_id)
     }
 
+    pub fn infer_call_receiver_type(&self, call_expr: &LuaCallExpr) -> Option<LuaType> {
+        infer_call_receiver_type(self.db, &mut self.infer_cache.borrow_mut(), call_expr)
+    }
+
     pub fn get_index_decl_type(&self, index_expr: LuaIndexExpr) -> Option<LuaType> {
         let cache = &mut self.infer_cache.borrow_mut();
         infer_index_expr(self.db, cache, index_expr, false).ok()