Some later infer logical

CppCXY · CppCXY · commit 8511576612df · 2025-07-24T15:37:26.000+08:00
diff --git a/crates/emmylua_code_analysis/src/db_index/type/mod.rs b/crates/emmylua_code_analysis/src/db_index/type/mod.rs
@@ -15,6 +15,7 @@ pub use type_decl::{
 };
 pub use type_ops::TypeOps;
 pub use type_owner::{LuaTypeCache, LuaTypeOwner};
+pub use type_visit_trait::TypeVisitTrait;
 pub use types::*;
 
 #[derive(Debug)]
diff --git a/crates/emmylua_code_analysis/src/db_index/type/types.rs b/crates/emmylua_code_analysis/src/db_index/type/types.rs
@@ -680,18 +680,6 @@ impl LuaFunctionType {
             false
         }
     }
-
-    pub fn collect_generic_tpls(&self, tpls: &mut HashSet<GenericTplId>) {
-        self.visit_type(&mut |t| match t {
-            LuaType::TplRef(generic_tpl) | LuaType::ConstTplRef(generic_tpl) => {
-                tpls.insert(generic_tpl.get_tpl_id());
-            }
-            LuaType::StrTplRef(str_tpl) => {
-                tpls.insert(str_tpl.get_tpl_id());
-            }
-            _ => {}
-        });
-    }
 }
 
 impl From<LuaFunctionType> for LuaType {
diff --git a/crates/emmylua_code_analysis/src/semantic/generic/instantiate_func_generic.rs b/crates/emmylua_code_analysis/src/semantic/generic/instantiate_func_generic.rs
@@ -5,34 +5,57 @@ use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr};
 use crate::{
     db_index::{DbIndex, LuaType},
     semantic::{
-        generic::tpl_context::TplContext, infer::InferFailReason, infer_expr, LuaInferCache,
+        generic::{
+            tpl_context::TplContext,
+            tpl_pattern::{
+                multi_param_tpl_pattern_match_multi_return, tpl_pattern_match,
+                variadic_tpl_pattern_match,
+            },
+        },
+        infer::InferFailReason,
+        infer_expr, LuaInferCache,
     },
-    LuaFunctionType,
+    LuaFunctionType, TypeVisitTrait,
 };
 
-use super::{
-    instantiate_type_generic::instantiate_doc_function, tpl_pattern::tpl_pattern_match_args,
-    TypeSubstitutor,
-};
+use super::{instantiate_type_generic::instantiate_doc_function, TypeSubstitutor};
 
 pub fn instantiate_func_generic(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     func: &LuaFunctionType,
     call_expr: LuaCallExpr,
 ) -> Result<LuaFunctionType, InferFailReason> {
+    let mut generic_tpls = HashSet::new();
+    func.visit_type(&mut |t| match t {
+        LuaType::TplRef(generic_tpl) | LuaType::ConstTplRef(generic_tpl) => {
+            let tpl_id = generic_tpl.get_tpl_id();
+            if tpl_id.is_func() {
+                generic_tpls.insert(tpl_id);
+            }
+        }
+        LuaType::StrTplRef(str_tpl) => {
+            generic_tpls.insert(str_tpl.get_tpl_id());
+        }
+        _ => {}
+    });
+    if generic_tpls.is_empty() {
+        return Ok(func.clone());
+    }
+
     let origin_params = func.get_params();
-    let func_param_types: Vec<_> = origin_params
+    let mut func_param_types: Vec<_> = origin_params
         .iter()
         .map(|(_, t)| t.clone().unwrap_or(LuaType::Unknown))
         .collect();
-    let func_return_type = func.get_ret();
 
-    let mut generic_tpls = HashSet::new();
-    func.collect_generic_tpls(&mut generic_tpls);
-
-    let mut arg_types = collect_arg_types(db, cache, &call_expr)?;
+    let arg_exprs = call_expr
+        .get_args_list()
+        .ok_or(InferFailReason::None)?
+        .get_args()
+        .collect::<Vec<_>>();
     let mut substitutor = TypeSubstitutor::new();
+    substitutor.add_need_infer_tpls(generic_tpls);
     let mut context = TplContext {
         db,
         cache,
@@ -44,17 +67,81 @@ pub fn instantiate_func_generic(
     let colon_define = func.is_colon_define();
     match (colon_define, colon_call) {
         (true, false) => {
-            if !arg_types.is_empty() {
-                arg_types.remove(0);
-            }
+            func_param_types.insert(0, LuaType::Any);
         }
         (false, true) => {
-            arg_types.insert(0, LuaType::Any);
+            if !func_param_types.is_empty() {
+                func_param_types.remove(0);
+            }
         }
         _ => {}
     }
 
-    tpl_pattern_match_args(&mut context, &func_param_types, &arg_types)?;
+    let mut unresolve_tpls = vec![];
+    for i in 0..func_param_types.len() {
+        if i >= arg_exprs.len() {
+            break;
+        }
+
+        if context.substitutor.is_infer_all_tpl() {
+            break;
+        }
+
+        let func_param_type = &func_param_types[i];
+        let call_arg_expr = &arg_exprs[i];
+        if !func_param_type.contain_tpl() {
+            continue;
+        }
+
+        if !func_param_type.is_variadic() {
+            if let LuaExpr::ClosureExpr(_) = call_arg_expr {
+                // If the argument is a closure, we cannot infer the type from it.
+                // We will handle this case later.
+                unresolve_tpls.push((func_param_type.clone(), call_arg_expr.clone()));
+                continue;
+            }
+        }
+
+        let arg_type = infer_expr(db, context.cache, call_arg_expr.clone())?;
+
+        match (func_param_type, &arg_type) {
+            (LuaType::Variadic(variadic), _) => {
+                let mut arg_types = vec![];
+                for arg_expr in &arg_exprs[i..] {
+                    let arg_type = infer_expr(db, context.cache, arg_expr.clone())?;
+                    arg_types.push(arg_type);
+                }
+
+                variadic_tpl_pattern_match(&mut context, variadic, &arg_types)?;
+                break;
+            }
+            (_, LuaType::Variadic(variadic)) => {
+                multi_param_tpl_pattern_match_multi_return(
+                    &mut context,
+                    &func_param_types[i..],
+                    variadic,
+                )?;
+                break;
+            }
+            _ => {
+                tpl_pattern_match(&mut context, func_param_type, &arg_type)?;
+            }
+        }
+    }
+
+    if !context.substitutor.is_infer_all_tpl() {
+        for (func_param_type, call_arg_expr) in unresolve_tpls {
+            if let LuaExpr::ClosureExpr(_) = call_arg_expr {
+                // If the argument is a closure, we cannot infer the type from it.
+                // We will handle this case later.
+                continue;
+            }
+
+            let closure_type = infer_expr(db, context.cache, call_arg_expr)?;
+
+            tpl_pattern_match(&mut context, &func_param_type, &closure_type)?;
+        }
+    }
 
     if func.contain_self() {
         infer_self_type(db, cache, &call_expr, &mut substitutor)?;
@@ -67,21 +154,6 @@ pub fn instantiate_func_generic(
     }
 }
 
-fn collect_arg_types(
-    db: &DbIndex,
-    cache: &mut LuaInferCache,
-    call_expr: &LuaCallExpr,
-) -> Result<Vec<LuaType>, InferFailReason> {
-    let arg_list = call_expr.get_args_list().ok_or(InferFailReason::None)?;
-    let mut arg_types = Vec::new();
-    for arg in arg_list.get_args() {
-        let arg_type = infer_expr(db, cache, arg.clone())?;
-        arg_types.push(arg_type);
-    }
-
-    Ok(arg_types)
-}
-
 fn infer_self_type(
     db: &DbIndex,
     cache: &mut LuaInferCache,
diff --git a/crates/emmylua_code_analysis/src/semantic/generic/instantiate_type_generic.rs b/crates/emmylua_code_analysis/src/semantic/generic/instantiate_type_generic.rs
@@ -65,6 +65,7 @@ fn instantiate_tuple(db: &DbIndex, tuple: &LuaTupleType, substitutor: &TypeSubst
                     if let LuaType::TplRef(tpl) = base {
                         if let Some(value) = substitutor.get(tpl.get_tpl_id()) {
                             match value {
+                                SubstitutorValue::None => {}
                                 SubstitutorValue::MultiTypes(types) => {
                                     for typ in types {
                                         new_types.push(typ.clone());
@@ -124,6 +125,12 @@ pub fn instantiate_doc_function(
                                         new_params.push(param.clone());
                                     }
                                 }
+                                SubstitutorValue::MultiTypes(types) => {
+                                    for (i, typ) in types.iter().enumerate() {
+                                        let param_name = format!("param{}", i);
+                                        new_params.push((param_name, Some(typ.clone())));
+                                    }
+                                }
                                 _ => {
                                     new_params.push((
                                         "...".to_string(),
@@ -255,6 +262,7 @@ fn instantiate_table_generic(
 fn instantiate_tpl_ref(_: &DbIndex, tpl: &GenericTpl, substitutor: &TypeSubstitutor) -> LuaType {
     if let Some(value) = substitutor.get(tpl.get_tpl_id()) {
         match value {
+            SubstitutorValue::None => {}
             SubstitutorValue::Type(ty) => return ty.clone(),
             SubstitutorValue::MultiTypes(types) => {
                 return types.first().unwrap_or(&LuaType::Unknown).clone();
@@ -313,6 +321,7 @@ fn instantiate_variadic_type(
             if let LuaType::TplRef(tpl) = base {
                 if let Some(value) = substitutor.get(tpl.get_tpl_id()) {
                     match value {
+                        SubstitutorValue::None => {}
                         SubstitutorValue::Type(ty) => return ty.clone(),
                         SubstitutorValue::MultiTypes(types) => {
                             return LuaType::Variadic(VariadicType::Multi(types.clone()).into())
diff --git a/crates/emmylua_code_analysis/src/semantic/generic/tpl_pattern.rs b/crates/emmylua_code_analysis/src/semantic/generic/tpl_pattern.rs
@@ -33,7 +33,7 @@ pub fn tpl_pattern_match_args(
 
         match (func_param_type, call_arg_type) {
             (LuaType::Variadic(variadic), _) => {
-                variadic_tpl_pattern_match(variadic, &call_arg_types[i..], context.substitutor)?;
+                variadic_tpl_pattern_match(context, variadic, &call_arg_types[i..])?;
                 break;
             }
             (_, LuaType::Variadic(variadic)) => {
@@ -53,7 +53,7 @@ pub fn tpl_pattern_match_args(
     Ok(())
 }
 
-fn multi_param_tpl_pattern_match_multi_return(
+pub fn multi_param_tpl_pattern_match_multi_return(
     context: &mut TplContext,
     func_param_types: &[LuaType],
     multi_return: &VariadicType,
@@ -97,7 +97,7 @@ fn multi_param_tpl_pattern_match_multi_return(
     Ok(())
 }
 
-fn tpl_pattern_match(
+pub fn tpl_pattern_match(
     context: &mut TplContext,
     pattern: &LuaType,
     target: &LuaType,
@@ -639,12 +639,12 @@ fn return_type_pattern_match_target_type(
                     }
                 },
                 VariadicType::Multi(target_types) => {
-                    variadic_tpl_pattern_match(variadic_source, target_types, context.substitutor)?;
+                    variadic_tpl_pattern_match(context, variadic_source, target_types)?;
                 }
             }
         }
         (LuaType::Variadic(variadic), _) => {
-            variadic_tpl_pattern_match(variadic, &[target.clone()], context.substitutor)?;
+            variadic_tpl_pattern_match(context, variadic, &[target.clone()])?;
         }
         (_, LuaType::Variadic(variadic)) => {
             multi_param_tpl_pattern_match_multi_return(context, &[source.clone()], variadic)?;
@@ -682,23 +682,27 @@ fn func_varargs_tpl_pattern_match(
 }
 
 pub fn variadic_tpl_pattern_match(
+    context: &mut TplContext,
     tpl: &VariadicType,
     target_rest_types: &[LuaType],
-    substitutor: &mut TypeSubstitutor,
 ) -> TplPatternMatchResult {
     match tpl {
         VariadicType::Base(base) => {
             if let LuaType::TplRef(tpl_ref) = base {
                 let tpl_id = tpl_ref.get_tpl_id();
                 match target_rest_types.len() {
                     0 => {
-                        substitutor.insert_type(tpl_id, LuaType::Nil);
+                        context.substitutor.insert_type(tpl_id, LuaType::Nil);
                     }
                     1 => {
-                        substitutor.insert_type(tpl_id, target_rest_types[0].clone());
+                        context
+                            .substitutor
+                            .insert_type(tpl_id, target_rest_types[0].clone());
                     }
                     _ => {
-                        substitutor.insert_multi_types(tpl_id, target_rest_types.to_vec());
+                        context
+                            .substitutor
+                            .insert_multi_types(tpl_id, target_rest_types.to_vec());
                     }
                 }
             }
@@ -708,11 +712,7 @@ pub fn variadic_tpl_pattern_match(
                 match ret_type {
                     LuaType::Variadic(inner) => {
                         if i < target_rest_types.len() {
-                            variadic_tpl_pattern_match(
-                                inner,
-                                &target_rest_types[i..],
-                                substitutor,
-                            )?;
+                            variadic_tpl_pattern_match(context, inner, &target_rest_types[i..])?;
                         }
 
                         break;
@@ -721,7 +721,7 @@ pub fn variadic_tpl_pattern_match(
                         let tpl_id = tpl_ref.get_tpl_id();
                         match target_rest_types.get(i) {
                             Some(t) => {
-                                substitutor.insert_type(tpl_id, t.clone());
+                                context.substitutor.insert_type(tpl_id, t.clone());
                             }
                             None => {
                                 break;
@@ -752,7 +752,7 @@ fn tuple_tpl_pattern_match(
 
                 if let LuaType::Variadic(inner) = tpl_type {
                     let target_rest_types = &target_tuple_types[i..];
-                    variadic_tpl_pattern_match(inner, target_rest_types, context.substitutor)?;
+                    variadic_tpl_pattern_match(context, inner, target_rest_types)?;
                     break;
                 }
 
diff --git a/crates/emmylua_code_analysis/src/semantic/generic/type_substitutor.rs b/crates/emmylua_code_analysis/src/semantic/generic/type_substitutor.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use crate::{GenericTplId, LuaType, LuaTypeDeclId};
 
@@ -42,6 +42,23 @@ impl TypeSubstitutor {
         }
     }
 
+    pub fn add_need_infer_tpls(&mut self, tpl_ids: HashSet<GenericTplId>) {
+        for tpl_id in tpl_ids {
+            if !self.tpl_replace_map.contains_key(&tpl_id) {
+                self.tpl_replace_map.insert(tpl_id, SubstitutorValue::None);
+            }
+        }
+    }
+
+    pub fn is_infer_all_tpl(&self) -> bool {
+        for value in self.tpl_replace_map.values() {
+            if let SubstitutorValue::None = value {
+                return false;
+            }
+        }
+        true
+    }
+
     pub fn insert_type(&mut self, tpl_id: GenericTplId, replace_type: LuaType) {
         if !self.can_insert_type(tpl_id) {
             return;
@@ -53,8 +70,8 @@ impl TypeSubstitutor {
 
     fn can_insert_type(&self, tpl_id: GenericTplId) -> bool {
         if let Some(value) = self.tpl_replace_map.get(&tpl_id) {
-            if let SubstitutorValue::Type(typ) = value {
-                return typ.is_any();
+            if let SubstitutorValue::None = value {
+                return true;
             }
 
             return false;
@@ -140,6 +157,7 @@ fn convert_type_def_to_ref(ty: &LuaType) -> LuaType {
 
 #[derive(Debug, Clone)]
 pub enum SubstitutorValue {
+    None,
     Type(LuaType),
     Params(Vec<(String, Option<LuaType>)>),
     MultiTypes(Vec<LuaType>),

Original file line number	Diff line number	Diff line change
`@@ -680,18 +680,6 @@ impl LuaFunctionType {`
`680`	`680`	`false`
`681`	`681`	`}`
`682`	`682`	`}`
`683`		`-`
`684`		`- pub fn collect_generic_tpls(&self, tpls: &mut HashSet<GenericTplId>) {`
`685`		`- self.visit_type(&mut \|t\| match t {`
`686`		`- LuaType::TplRef(generic_tpl) \| LuaType::ConstTplRef(generic_tpl) => {`
`687`		`- tpls.insert(generic_tpl.get_tpl_id());`
`688`		`- }`
`689`		`- LuaType::StrTplRef(str_tpl) => {`
`690`		`- tpls.insert(str_tpl.get_tpl_id());`
`691`		`- }`
`692`		`- _ => {}`
`693`		`- });`
`694`		`- }`
`695`	`683`	`}`
`696`	`684`
`697`	`685`	`impl From<LuaFunctionType> for LuaType {`