fix param-type-check and missing-parameter check

Author: CppCXY

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

@@ -1,4 +1,6 @@
-use emmylua_parser::{LuaAstNode, LuaAstToken, LuaCallExpr, LuaGeneralToken, LuaLiteralExpr, LuaLiteralToken};
+use emmylua_parser::{
+    LuaAstNode, LuaAstToken, LuaCallExpr, LuaGeneralToken, LuaLiteralExpr, LuaLiteralToken,
+};
 
 use crate::{DiagnosticCode, SemanticModel};
 
@@ -22,19 +24,33 @@ fn check_call_expr(
 ) -> Option<()> {
     let func = semantic_model.infer_call_expr_func(call_expr.clone(), None)?;
     let params = func.get_params();
-    let args_count = call_expr.get_args_list()?.get_args().count();
+    let mut args_count = call_expr.get_args_list()?.get_args().count();
+    let colon_call = call_expr.is_colon_call();
+    let colon_define = func.is_colon_define();
+    match (colon_call, colon_define) {
+        (true, true) | (false, false) => {}
+        (false, true) => {
+            if args_count > 0 {
+                args_count -= 1;
+            }
+        }
+        (true, false) => {
+            args_count += 1;
+        }
+    }
+
     if args_count < params.len() {
         // fix last arg is `...`
         if args_count != 0 {
-            let last_arg = call_expr.get_args_list()?.child::<LuaLiteralExpr>()?;
-            if let Some(literal_token) = last_arg.get_literal() {
-                if let LuaLiteralToken::Dots(_) = literal_token {
-                    return Some(());
+            if let Some(last_arg) = call_expr.get_args_list()?.child::<LuaLiteralExpr>() {
+                if let Some(literal_token) = last_arg.get_literal() {
+                    if let LuaLiteralToken::Dots(_) = literal_token {
+                        return Some(());
+                    }
                 }
             }
         }
 
-
         let mut miss_parameter_info = Vec::new();
         for i in args_count..params.len() {
             let param_info = params.get(i)?;
@@ -61,7 +77,8 @@ fn check_call_expr(
                     num = params.len(),
                     found_num = args_count,
                     infos = miss_parameter_info.join("\n")
-                ).to_string(),
+                )
+                .to_string(),
                 None,
             );
         }

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

@@ -28,39 +28,65 @@ fn check_call_expr(
 ) -> 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<_>>();
+    let mut args = call_expr
+        .get_args_list()?
+        .get_args()
+        .map(|arg| Some(arg))
+        .collect::<Vec<_>>();
+    let colon_call = call_expr.is_colon_call();
+    let colon_define = func.is_colon_define();
+    match (colon_call, colon_define) {
+        (true, true) | (false, false) => {}
+        (false, true) => {
+            if args.len() > 0 {
+                args.remove(0);
+            }
+        }
+        (true, false) => {
+            args.insert(0, None);
+        }
+    }
+
     for (idx, param) in params.iter().enumerate() {
         if idx >= args.len() {
             break;
         }
 
+        let arg = &args[idx];
+        if arg.is_none() {
+            continue;
+        }
+        let arg = arg.clone().unwrap();
+
         if param.0 == "..." {
             if param.1.is_none() {
                 break;
             }
 
             let param_type = param.1.clone().unwrap();
             for arg in args.iter().skip(idx) {
-                let mut expr_type = semantic_model
-                    .infer_expr(arg.clone())
-                    .unwrap_or(LuaType::Any);
-                // treat unknown type as any
-                if expr_type.is_unknown() {
-                    expr_type = LuaType::Any;
-                }
+                if let Some(arg) = arg {
+                    let mut expr_type = semantic_model
+                        .infer_expr(arg.clone())
+                        .unwrap_or(LuaType::Any);
+                    // treat unknown type as any
+                    if expr_type.is_unknown() {
+                        expr_type = 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,
-                    );
+                    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,
+                        );
+                    }
                 }
             }
         } else {
@@ -69,7 +95,6 @@ fn check_call_expr(
             }
 
             let param_type = param.1.clone().unwrap();
-            let arg = &args[idx];
             let mut expr_type = semantic_model
                 .infer_expr(arg.clone())
                 .unwrap_or(LuaType::Any);