add basic param type not match check

Author: CppCXY

…tes/emmylua_ls/src/util/humanize_type.rs …lysis/src/db_index/type/humanize_type.rscrates/emmylua_ls/src/util/humanize_type.rs renamed to crates/code_analysis/src/db_index/type/humanize_type.rs crates/emmylua_ls/src/util/humanize_type.rs renamed to crates/code_analysis/src/db_index/type/humanize_type.rs

@@ -1,4 +1,4 @@
-use code_analysis::{
+use crate::{
     DbIndex, GenericTpl, LuaExistFieldType, LuaExtendedType, LuaFunctionType, LuaGenericType,
     LuaInstanceType, LuaIntersectionType, LuaMemberKey, LuaMultiReturn, LuaObjectType,
     LuaSignatureId, LuaStringTplType, LuaTupleType, LuaType, LuaTypeDeclId, LuaUnionType,

crates/code_analysis/src/db_index/type/mod.rs

@@ -1,3 +1,4 @@
+mod humanize_type;
 mod test;
 mod type_assert;
 mod type_decl;
@@ -10,8 +11,11 @@ use flagset::FlagSet;
 use rowan::TextRange;
 use std::collections::HashMap;
 pub use type_assert::TypeAssertion;
-pub use type_decl::{LuaDeclTypeKind, LuaTypeAttribute, LuaTypeDecl, LuaTypeDeclId, LuaDeclLocation};
+pub use type_decl::{
+    LuaDeclLocation, LuaDeclTypeKind, LuaTypeAttribute, LuaTypeDecl, LuaTypeDeclId,
+};
 pub use types::*;
+pub use humanize_type::humanize_type;
 
 #[derive(Debug)]
 pub struct LuaTypeIndex {

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

@@ -8,6 +8,7 @@ mod missing_parameter;
 mod syntax_error;
 mod undefined_global;
 mod unused;
+mod param_type_check;
 
 use lsp_types::{Diagnostic, DiagnosticSeverity, DiagnosticTag, NumberOrString};
 use rowan::TextRange;
@@ -45,6 +46,7 @@ pub fn check_file(
     check!(local_const_reassign);
     check!(discard_returns);
     check!(await_in_sync);
+    check!(param_type_check);
 
     Some(())
 }

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

@@ -0,0 +1,65 @@
+use emmylua_parser::{LuaAst, LuaAstNode, LuaCallExpr};
+
+use crate::{humanize_type, DiagnosticCode, LuaType, SemanticModel};
+
+use super::DiagnosticContext;
+
+pub const CODES: &[DiagnosticCode] = &[DiagnosticCode::ParamTypeNotMatch];
+
+/// a simple implementation of param type check, later we will do better
+pub fn check(context: &mut DiagnosticContext, semantic_model: &mut SemanticModel) -> Option<()> {
+    let root = semantic_model.get_root().clone();
+    for node in root.descendants::<LuaAst>() {
+        match node {
+            LuaAst::LuaCallExpr(call_expr) => {
+                check_call_expr(context, semantic_model, call_expr);
+            }
+            _ => {}
+        }
+    }
+
+    Some(())
+}
+
+fn check_call_expr(
+    context: &mut DiagnosticContext,
+    semantic_model: &mut SemanticModel,
+    call_expr: LuaCallExpr,
+) -> Option<()> {
+    let func = semantic_model.infer_call_expr_func(call_expr.clone(), None)?;
+    let params = func.get_params();
+    let args = call_expr.get_args_list()?.get_args().collect::<Vec<_>>();
+    for (idx, param) in params.iter().enumerate() {
+        if idx >= args.len() {
+            break;
+        }
+
+        if param.0 == "..." {
+        } else {
+            if param.1.is_none() {
+                continue;
+            }
+
+            let param_type = param.1.clone().unwrap();
+            let arg = &args[idx];
+            let expr_type = semantic_model
+                .infer_expr(arg.clone())
+                .unwrap_or(LuaType::Any);
+            if !semantic_model.check_type_compact(&param_type, &expr_type) {
+                let db = semantic_model.get_db();
+                context.add_diagnostic(
+                    DiagnosticCode::ParamTypeNotMatch,
+                    arg.get_range(),
+                    format!(
+                        "expected {} but founded {}",
+                        humanize_type(db, &param_type),
+                        humanize_type(db, &expr_type)
+                    ),
+                    None,
+                );
+            }
+        }
+    }
+
+    Some(())
+}

crates/code_analysis/src/diagnostic/lua_diagnostic_code.rs

@@ -14,8 +14,8 @@ pub enum DiagnosticCode {
     TypeNotFound,
     /// Missing return statement
     MissingReturn,
-    /// Type not match
-    TypeNotMatch,
+    /// Param Type not match
+    ParamTypeNotMatch,
     /// Missing parameter
     MissingParameter,
     /// Inject field fail
@@ -63,7 +63,7 @@ pub fn get_default_severity(code: DiagnosticCode) -> DiagnosticSeverity {
         DiagnosticCode::SyntaxError => DiagnosticSeverity::ERROR,
         DiagnosticCode::TypeNotFound => DiagnosticSeverity::WARNING,
         DiagnosticCode::MissingReturn => DiagnosticSeverity::WARNING,
-        DiagnosticCode::TypeNotMatch => DiagnosticSeverity::WARNING,
+        DiagnosticCode::ParamTypeNotMatch => DiagnosticSeverity::WARNING,
         DiagnosticCode::MissingParameter => DiagnosticSeverity::WARNING,
         DiagnosticCode::InjectFieldFail => DiagnosticSeverity::ERROR,
         DiagnosticCode::UnreachableCode => DiagnosticSeverity::HINT,
@@ -82,7 +82,6 @@ pub fn get_default_severity(code: DiagnosticCode) -> DiagnosticSeverity {
 
 pub fn is_code_default_enable(code: &DiagnosticCode) -> bool {
     match code {
-        DiagnosticCode::TypeNotFound => false,
         DiagnosticCode::InjectFieldFail => false,
         DiagnosticCode::DisableGlobalDefine => false,
         DiagnosticCode::UndefinedField => false,

crates/code_analysis/src/semantic/mod.rs

@@ -23,7 +23,7 @@ use semantic_info::{
     infer_node_property_owner, infer_node_semantic_info, infer_token_property_owner,
     infer_token_semantic_info,
 };
-use type_compact::is_sub_type_of;
+use type_compact::{check_type_compact, is_sub_type_of};
 use visibility::check_visibility;
 
 use crate::LuaFunctionType;
@@ -90,6 +90,10 @@ impl<'a> SemanticModel<'a> {
         infer_members(self.db, prefix_type)
     }
 
+    pub fn check_type_compact(&mut self, source: &LuaType, compact_type: &LuaType) -> bool {
+        check_type_compact(self.db, &mut self.infer_config,source, compact_type)
+    }
+
     pub fn infer_call_expr_func(
         &mut self,
         call_expr: LuaCallExpr,

crates/code_analysis/src/semantic/type_compact/mod.rs

@@ -11,7 +11,6 @@ use crate::db_index::{
 use super::{InferGuard, LuaInferConfig};
 pub use sub_type::is_sub_type_of;
 
-#[allow(unused)]
 pub fn check_type_compact(
     db: &DbIndex,
     config: &mut LuaInferConfig,

crates/emmylua_ls/src/handlers/completion/add_completions/mod.rs

@@ -8,7 +8,7 @@ use lsp_types::CompletionItemKind;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use crate::util::humanize_type;
+use code_analysis::humanize_type;
 
 use super::completion_builder::CompletionBuilder;
 

crates/emmylua_ls/src/handlers/completion/providers/type_special_provider.rs

@@ -8,13 +8,10 @@ use emmylua_parser::{
 };
 use lsp_types::CompletionItem;
 
-use crate::{
-    handlers::{
-        completion::completion_builder::CompletionBuilder,
-        signature_helper::get_current_param_index,
-    },
-    util::humanize_type,
+use crate::handlers::{
+    completion::completion_builder::CompletionBuilder, signature_helper::get_current_param_index,
 };
+use code_analysis::humanize_type;
 
 pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
     if builder.is_cancelled() {

crates/emmylua_ls/src/handlers/hover/build_hover.rs

@@ -5,7 +5,7 @@ use code_analysis::{
 use emmylua_parser::LuaSyntaxToken;
 use lsp_types::{Hover, HoverContents, MarkedString, MarkupContent};
 
-use crate::util::humanize_type;
+use code_analysis::humanize_type;
 
 use super::hover_humanize::{hover_const_type, hover_function_type};