support closure param infer

Author: CppCXY

crates/code_analysis/src/compilation/analyzer/decl/exprs.rs

@@ -1,10 +1,10 @@
 use emmylua_parser::{
-    LuaAstNode, LuaAstToken, LuaClosureExpr, LuaIndexExpr, LuaIndexKey, LuaNameExpr, LuaTableExpr
+    LuaAstNode, LuaAstToken, LuaClosureExpr, LuaIndexExpr, LuaIndexKey, LuaNameExpr, LuaTableExpr,
 };
 
 use crate::{
     db_index::{LuaDecl, LuaMember, LuaMemberKey, LuaMemberOwner},
-    InFiled, LuaDeclId,
+    InFiled, LuaDeclId, LuaSignatureId,
 };
 
 use super::DeclAnalyzer;
@@ -77,6 +77,7 @@ pub fn analyze_index_expr(analyzer: &mut DeclAnalyzer, expr: LuaIndexExpr) -> Op
 
 pub fn analyze_closure_expr(analyzer: &mut DeclAnalyzer, expr: LuaClosureExpr) -> Option<()> {
     let params = expr.get_params_list()?;
+    let signature_id = LuaSignatureId::new(analyzer.get_file_id(), &expr);
 
     for param in params.get_params() {
         let name = param.get_name_token().map_or_else(
@@ -89,14 +90,12 @@ pub fn analyze_closure_expr(analyzer: &mut DeclAnalyzer, expr: LuaClosureExpr) -
             },
             |name_token| name_token.get_name_text().to_string(),
         );
-        
-        let decl = LuaDecl::Local {
+
+        let decl = LuaDecl::Param {
             name,
             file_id: analyzer.get_file_id(),
-            kind: param.syntax().kind().into(),
             range: param.get_range(),
-            attrib: None,
-            decl_type: None,
+            signature_id,
         };
 
         analyzer.add_decl(decl);

crates/code_analysis/src/compilation/analyzer/lua/closure.rs

@@ -1,7 +1,9 @@
-use emmylua_parser::{LuaAstNode, LuaClosureExpr, LuaFuncStat, LuaVarExpr};
+use emmylua_parser::{
+    LuaAstNode, LuaCallArgList, LuaCallExpr, LuaClosureExpr, LuaFuncStat, LuaVarExpr,
+};
 
 use crate::{
-    compilation::analyzer::unresolve::UnResolveReturn,
+    compilation::analyzer::unresolve::{UnResolveClosureParams, UnResolveReturn},
     db_index::{LuaDocReturnInfo, LuaSignatureId},
 };
 
@@ -12,6 +14,7 @@ pub fn analyze_closure(analyzer: &mut LuaAnalyzer, closure: LuaClosureExpr) -> O
 
     analyze_colon_define(analyzer, &signature_id, &closure);
     analyze_params(analyzer, &signature_id, &closure);
+    analyze_lambda_params(analyzer, &signature_id, &closure);
     analyze_return(analyzer, &signature_id, &closure);
     Some(())
 }
@@ -61,6 +64,30 @@ fn analyze_params(
     Some(())
 }
 
+fn analyze_lambda_params(
+    analyzer: &mut LuaAnalyzer,
+    signature_id: &LuaSignatureId,
+    closure: &LuaClosureExpr,
+) -> Option<()> {
+    let call_arg_list = closure.get_parent::<LuaCallArgList>()?;
+    let call_expr = call_arg_list.get_parent::<LuaCallExpr>()?;
+    let pos = closure.get_position();
+    let founded_idx = call_arg_list
+        .get_args()
+        .position(|arg| arg.get_position() == pos)?;
+
+    let unresolved = UnResolveClosureParams {
+        file_id: analyzer.file_id,
+        signature_id: signature_id.clone(),
+        call_expr,
+        param_idx: founded_idx,
+    };
+
+    analyzer.add_unresolved(unresolved.into());
+
+    Some(())
+}
+
 fn analyze_return(
     analyzer: &mut LuaAnalyzer,
     signature_id: &LuaSignatureId,

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

@@ -1,6 +1,7 @@
 mod infer_manager;
 mod merge_type;
 mod resolve;
+mod resolve_closure_param;
 
 use crate::{
     db_index::{DbIndex, LuaDeclId, LuaMemberId, LuaSignatureId},
@@ -9,7 +10,11 @@ use crate::{
 use emmylua_parser::{LuaCallExpr, LuaExpr};
 use infer_manager::InferManager;
 pub use merge_type::{merge_decl_expr_type, merge_member_type};
-use resolve::{try_resolve_decl, try_resolve_iter_var, try_resolve_member, try_resolve_module, try_resolve_return_point};
+use resolve::{
+    try_resolve_decl, try_resolve_iter_var, try_resolve_member,
+    try_resolve_module, try_resolve_return_point,
+};
+use resolve_closure_param::try_resolve_closure_params;
 
 use super::{lua::LuaReturnPoint, AnalyzeContext};
 
@@ -34,33 +39,28 @@ fn try_resolve(
     let mut changed = false;
     for i in 0..unresolves.len() {
         let un_resolve = &mut unresolves[i];
-
+        let file_id = un_resolve.get_file_id().unwrap_or(FileId { id: 0 });
+        let config = infer_manager.get_infer_config(file_id);
         let resolve = match un_resolve {
             UnResolve::Decl(un_resolve_decl) => {
-                let config = infer_manager.get_infer_config(un_resolve_decl.file_id);
                 try_resolve_decl(db, config, un_resolve_decl).unwrap_or(false)
             }
             UnResolve::Member(ref mut un_resolve_member) => {
-                let config = infer_manager.get_infer_config(un_resolve_member.file_id);
                 try_resolve_member(db, config, un_resolve_member).unwrap_or(false)
             }
             UnResolve::Module(un_resolve_module) => {
-                let config = infer_manager.get_infer_config(un_resolve_module.file_id);
                 try_resolve_module(db, config, un_resolve_module).unwrap_or(false)
             }
             UnResolve::Return(un_resolve_return) => {
-                let config = infer_manager.get_infer_config(un_resolve_return.file_id);
                 try_resolve_return_point(db, config, un_resolve_return).unwrap_or(false)
             }
-            // UnResolve::ClosureParams(un_resolve_closure_params) => {
-            //     todo!();
-            //     true
-            // }
+            UnResolve::ClosureParams(un_resolve_closure_params) => {
+                try_resolve_closure_params(db, config, un_resolve_closure_params).unwrap_or(false)
+            }
             UnResolve::IterDecl(un_resolve_iter_var) => {
-                let config = infer_manager.get_infer_config(un_resolve_iter_var.file_id);
                 try_resolve_iter_var(db, config, un_resolve_iter_var).unwrap_or(false)
             }
-            UnResolve::ClosureParams(_) | UnResolve::None => continue,
+            UnResolve::None => continue,
         };
 
         if resolve {
@@ -72,7 +72,6 @@ fn try_resolve(
     changed
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum UnResolve {
     None,
@@ -84,6 +83,27 @@ pub enum UnResolve {
     ClosureParams(Box<UnResolveClosureParams>),
 }
 
+#[allow(dead_code)]
+impl UnResolve {
+    pub fn is_none(&self) -> bool {
+        matches!(self, UnResolve::None)
+    }
+
+    pub fn get_file_id(&self) -> Option<FileId> {
+        match self {
+            UnResolve::Decl(un_resolve_decl) => Some(un_resolve_decl.file_id),
+            UnResolve::IterDecl(un_resolve_iter_var) => Some(un_resolve_iter_var.file_id),
+            UnResolve::Member(un_resolve_member) => Some(un_resolve_member.file_id),
+            UnResolve::Module(un_resolve_module) => Some(un_resolve_module.file_id),
+            UnResolve::Return(un_resolve_return) => Some(un_resolve_return.file_id),
+            UnResolve::ClosureParams(un_resolve_closure_params) => {
+                Some(un_resolve_closure_params.file_id)
+            }
+            UnResolve::None => None,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct UnResolveDecl {
     pub file_id: FileId,
@@ -138,7 +158,6 @@ impl From<UnResolveReturn> for UnResolve {
     }
 }
 
-#[allow(unused)]
 #[derive(Debug)]
 pub struct UnResolveClosureParams {
     pub file_id: FileId,

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

@@ -5,7 +5,8 @@ use crate::{
 };
 
 use super::{
-    merge_decl_expr_type, merge_member_type, UnResolveDecl, UnResolveIterVar, UnResolveMember, UnResolveModule, UnResolveReturn
+    merge_decl_expr_type, merge_member_type, UnResolveDecl, UnResolveIterVar, UnResolveMember,
+    UnResolveModule, UnResolveReturn,
 };
 
 pub fn try_resolve_decl(
@@ -157,8 +158,11 @@ pub fn try_resolve_iter_var(
         _ => return Some(true),
     };
 
-    let iter_type = func.get_ret().get(iter_var.ret_idx).unwrap_or(&LuaType::Nil);
+    let iter_type = func
+        .get_ret()
+        .get(iter_var.ret_idx)
+        .unwrap_or(&LuaType::Nil);
     let decl_id = iter_var.decl_id;
     merge_decl_expr_type(db, decl_id, iter_type.clone());
     Some(true)
-}
+}