add completion for function type

Author: CppCXY

Cargo.lock

@@ -19,6 +19,7 @@ pub fn try_resolve_closure_params(
         call_expr,
         call_expr_type,
         &mut InferGuard::new(),
+        None
     )?;
 
     let signature = db

crates/code_analysis/src/compilation/analyzer/unresolve/resolve_closure_param.rs

@@ -17,29 +17,41 @@ pub fn infer_call_expr_func(
     call_expr: LuaCallExpr,
     call_expr_type: LuaType,
     infer_guard: &mut InferGuard,
+    args_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
     match call_expr_type {
         LuaType::DocFunction(func) => Some(func),
-        LuaType::Signature(signature_id) => {
-            infer_signature_doc_function(db, config, signature_id.clone(), call_expr.clone())
-        }
+        LuaType::Signature(signature_id) => infer_signature_doc_function(
+            db,
+            config,
+            signature_id.clone(),
+            call_expr.clone(),
+            args_count,
+        ),
         LuaType::Def(type_def_id) => infer_type_doc_function(
             db,
             config,
             type_def_id.clone(),
             call_expr.clone(),
             infer_guard,
+            args_count,
         ),
         LuaType::Ref(type_ref_id) => infer_type_doc_function(
             db,
             config,
             type_ref_id.clone(),
             call_expr.clone(),
             infer_guard,
+            args_count,
+        ),
+        LuaType::Generic(generic) => infer_generic_type_doc_function(
+            db,
+            config,
+            &generic,
+            call_expr.clone(),
+            infer_guard,
+            args_count,
         ),
-        LuaType::Generic(generic) => {
-            infer_generic_type_doc_function(db, config, &generic, call_expr.clone(), infer_guard)
-        }
         _ => return None,
     }
 }
@@ -49,6 +61,7 @@ fn infer_signature_doc_function(
     config: &mut LuaInferConfig,
     signature_id: LuaSignatureId,
     call_expr: LuaCallExpr,
+    args_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
     let signature = db.get_signature_index().get(&signature_id)?;
     let overloads = &signature.overloads;
@@ -89,6 +102,7 @@ fn infer_signature_doc_function(
             call_expr.clone(),
             signature.is_colon_define,
             signature.is_generic(),
+            args_count,
         )?;
 
         Some(doc_func)
@@ -101,12 +115,20 @@ fn infer_type_doc_function(
     type_id: LuaTypeDeclId,
     call_expr: LuaCallExpr,
     infer_guard: &mut InferGuard,
+    args_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
     infer_guard.check(&type_id)?;
     let type_decl = db.get_type_index().get_type_decl(&type_id)?;
     if type_decl.is_alias() {
         let alias_type = type_decl.get_alias_origin()?;
-        return infer_call_expr_func(db, config, call_expr, alias_type.clone(), infer_guard);
+        return infer_call_expr_func(
+            db,
+            config,
+            call_expr,
+            alias_type.clone(),
+            infer_guard,
+            args_count,
+        );
     } else if type_decl.is_enum() {
         return None;
     }
@@ -126,7 +148,15 @@ fn infer_type_doc_function(
         }
     }
 
-    let doc_func = resolve_signature(db, config, overloads, call_expr.clone(), false, false)?;
+    let doc_func = resolve_signature(
+        db,
+        config,
+        overloads,
+        call_expr.clone(),
+        false,
+        false,
+        args_count,
+    )?;
     Some(doc_func)
 }
 
@@ -136,13 +166,21 @@ fn infer_generic_type_doc_function(
     generic: &LuaGenericType,
     call_expr: LuaCallExpr,
     infer_guard: &mut InferGuard,
+    args_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
     let type_id = generic.get_base_type_id();
     infer_guard.check(&type_id)?;
     let type_decl = db.get_type_index().get_type_decl(&type_id)?;
     if type_decl.is_alias() {
         let alias_type = type_decl.get_alias_origin()?;
-        return infer_call_expr_func(db, config, call_expr, alias_type.clone(), infer_guard);
+        return infer_call_expr_func(
+            db,
+            config,
+            call_expr,
+            alias_type.clone(),
+            infer_guard,
+            args_count,
+        );
     } else if type_decl.is_enum() {
         return None;
     }
@@ -164,6 +202,6 @@ fn infer_generic_type_doc_function(
         }
     }
 
-    let doc_func = resolve_signature(db, config, overloads, call_expr.clone(), false, false)?;
+    let doc_func = resolve_signature(db, config, overloads, call_expr.clone(), false, false, args_count)?;
     Some(doc_func)
 }

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

@@ -172,6 +172,7 @@ fn infer_call_by_signature(
             call_expr.clone(),
             signature.is_colon_define,
             signature.is_generic(),
+            None,
         )?;
         return infer_call_by_doc_function(
             db,
@@ -253,7 +254,7 @@ fn infer_call_by_custom_type(
         }
     }
 
-    let doc_func = resolve_signature(db, config, overloads, call_expr.clone(), false, false)?;
+    let doc_func = resolve_signature(db, config, overloads, call_expr.clone(), false, false, None)?;
     return infer_call_by_doc_function(db, config, &doc_func, call_expr, false);
 }
 
@@ -292,7 +293,7 @@ fn infer_call_by_custom_generic_type(
         }
     }
 
-    let doc_func = resolve_signature(db, config, overloads, call_expr.clone(), false, false)?;
+    let doc_func = resolve_signature(db, config, overloads, call_expr.clone(), false, false, None)?;
     return infer_call_by_doc_function(db, config, &doc_func, call_expr, false);
 }
 

crates/code_analysis/src/semantic/infer/infer_call.rs

@@ -86,6 +86,7 @@ impl<'a> SemanticModel<'a> {
     pub fn infer_call_expr_func(
         &mut self,
         call_expr: LuaCallExpr,
+        arg_count: Option<usize>,
     ) -> Option<Arc<LuaFunctionType>> {
         let prefix_expr = call_expr.get_prefix_expr()?;
         let call_expr_type = infer_expr(self.db, &mut self.infer_config, prefix_expr.into())?;
@@ -95,6 +96,7 @@ impl<'a> SemanticModel<'a> {
             call_expr,
             call_expr_type,
             &mut InferGuard::new(),
+            arg_count
         )
     }
 

crates/code_analysis/src/semantic/mod.rs

@@ -15,6 +15,7 @@ pub fn resolve_signature(
     call_expr: LuaCallExpr,
     colon_define: bool,
     is_generic: bool,
+    arg_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
     let args = call_expr.get_args_list()?;
     let mut expr_types = Vec::new();
@@ -44,9 +45,10 @@ pub fn resolve_signature(
             colon_define,
             call_expr,
             expr_types,
+            arg_count,
         );
     } else {
-        return resolve_signature_by_args(db, infer_config, overloads, expr_types);
+        return resolve_signature_by_args(db, infer_config, overloads, expr_types, arg_count);
     }
 }
 
@@ -57,8 +59,9 @@ fn resolve_signature_by_generic(
     colon_define: bool,
     call_expr: LuaCallExpr,
     expr_types: Vec<LuaType>,
+    arg_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
-    let mut max_match = 0;
+    let mut max_match = -1;
     let mut matched_func: Option<Arc<LuaFunctionType>> = None;
     let mut instantiate_funcs = Vec::new();
     for func in overloads {
@@ -91,13 +94,18 @@ fn resolve_signature_by_generic(
         instantiate_funcs.push(new_func);
     }
 
-    for func in instantiate_funcs {
+    for func in &instantiate_funcs {
         let params = func.get_params();
         let mut match_count = 0;
+        if params.len() < arg_count.unwrap_or(0) {
+            continue;
+        }
+
         for (i, param) in params.iter().enumerate() {
             if i >= expr_types.len() {
                 break;
             }
+
             let param_type = param.1.clone().unwrap_or(LuaType::Any);
             let expr_type = &expr_types[i];
             if param_type == LuaType::Any {
@@ -112,6 +120,10 @@ fn resolve_signature_by_generic(
         }
     }
 
+    if matched_func.is_none() && !instantiate_funcs.is_empty() {
+        matched_func = Some(instantiate_funcs[0].clone());
+    }
+
     matched_func
 }
 
@@ -120,16 +132,23 @@ fn resolve_signature_by_args(
     infer_config: &mut LuaInferConfig,
     overloads: Vec<Arc<LuaFunctionType>>,
     expr_types: Vec<LuaType>,
+    arg_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
     let mut max_match = -1;
     let mut matched_func: Option<Arc<LuaFunctionType>> = None;
-    for func in overloads {
+
+    for func in &overloads {
         let params = func.get_params();
         let mut match_count = 0;
+        if params.len() < arg_count.unwrap_or(0) {
+            continue;
+        }
+
         for (i, param) in params.iter().enumerate() {
             if i >= expr_types.len() {
                 break;
             }
+
             let param_type = param.1.clone().unwrap_or(LuaType::Any);
             let expr_type = &expr_types[i];
             if param_type == LuaType::Any {
@@ -144,5 +163,9 @@ fn resolve_signature_by_args(
         }
     }
 
+    if matched_func.is_none() && !overloads.is_empty() {
+        matched_func = Some(overloads[0].clone());
+    }
+
     matched_func
 }

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

@@ -1,4 +1,4 @@
-mod alias_or_enum_provider;
+mod type_special_provider;
 mod doc_name_token_provider;
 mod doc_tag_provider;
 mod doc_type_provider;
@@ -14,7 +14,7 @@ pub fn add_completions(builder: &mut CompletionBuilder) -> Option<()> {
     module_path_provider::add_completion(builder);
     file_path_provider::add_completion(builder);
     keywords_provider::add_completion(builder);
-    alias_or_enum_provider::add_completion(builder);
+    type_special_provider::add_completion(builder);
     env_provider::add_completion(builder);
     member_provider::add_completion(builder);
     doc_tag_provider::add_completion(builder);

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

@@ -1,5 +1,6 @@
 use code_analysis::{
-    InferGuard, LuaMemberId, LuaPropertyOwnerId, LuaType, LuaTypeDeclId, LuaUnionType,
+    InferGuard, LuaFunctionType, LuaMemberId, LuaPropertyOwnerId, LuaType, LuaTypeDeclId,
+    LuaUnionType,
 };
 use emmylua_parser::{
     LuaAstNode, LuaCallArgList, LuaCallExpr, LuaExpr, LuaSyntaxKind, LuaSyntaxToken, LuaTokenKind,
@@ -35,6 +36,9 @@ fn dispatch_type(
         LuaType::Nullable(typ) => {
             dispatch_type(builder, (*typ).clone(), infer_guard);
         }
+        LuaType::DocFunction(func) => {
+            add_lambda_completion(builder, &func);
+        }
         _ => {}
     }
 
@@ -127,10 +131,10 @@ fn infer_call_arg_list(
     token: LuaSyntaxToken,
 ) -> Option<LuaType> {
     let call_expr = call_arg_list.get_parent::<LuaCallExpr>()?;
+    let param_idx = get_current_param_index(&call_expr, &token)?;
     let call_expr_func = builder
         .semantic_model
-        .infer_call_expr_func(call_expr.clone())?;
-    let param_idx = get_current_param_index(&call_expr, &token)?;
+        .infer_call_expr_func(call_expr.clone(), Some(param_idx + 1))?;
 
     let typ = call_expr_func.get_params().get(param_idx)?.1.clone()?;
     Some(typ)
@@ -194,3 +198,25 @@ fn to_enum_label(builder: &CompletionBuilder, str: &str) -> String {
         format!("\"{}\"", str)
     }
 }
+
+fn add_lambda_completion(builder: &mut CompletionBuilder, func: &LuaFunctionType) -> Option<()> {
+    let params_str = func
+        .get_params()
+        .iter()
+        .map(|p| p.0.clone())
+        .collect::<Vec<_>>();
+    let label = format!("function ({}) end", params_str.join(", "));
+    let insert_text = format!("function ({})\n\t$0\nend", params_str.join(", "));
+
+    let completion_item = CompletionItem {
+        label,
+        kind: Some(lsp_types::CompletionItemKind::FUNCTION),
+        sort_text: Some("0".to_string()),
+        insert_text: Some(insert_text),
+        insert_text_format: Some(lsp_types::InsertTextFormat::SNIPPET),
+        ..Default::default()
+    };
+
+    builder.add_completion_item(completion_item);
+    Some(())
+}

crates/emmylua_ls/src/handlers/completion/providers/alias_or_enum_provider.rs renamed to crates/emmylua_ls/src/handlers/completion/providers/type_special_provider.rs

@@ -1,6 +1,6 @@
 [package]
 name = "emmylua_parser"
-version = "0.7.1"
+version = "0.8.0"
 edition = "2021"
 authors = ["CppCXY"]
 description = "A parser for EmmyLua and luals"

crates/emmylua_parser/Cargo.toml

@@ -261,6 +261,13 @@ fn parse_args(p: &mut LuaParser) -> ParseResult {
                 parse_expr(p)?;
                 while p.current_token() == LuaTokenKind::TkComma {
                     p.bump();
+                    if p.current_token() == LuaTokenKind::TkRightParen {
+                        p.push_error(LuaParseError::from_source_range(
+                            &t!("expect expression"),
+                            p.current_token_range(),
+                        ));
+                        break;
+                    }
                     parse_expr(p)?;
                 }
             }