perf: filter callable overloads

Author: xuhuanzy

crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs

@@ -1,14 +1,12 @@
 use std::sync::Arc;
 
 use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr, LuaIndexExpr, LuaSyntaxKind};
-use hashbrown::HashSet;
 use rowan::TextRange;
 
 use super::{
     super::{InferGuard, LuaInferCache, instantiate_type_generic, resolve_signature},
     InferFailReason, InferResult,
 };
-use crate::semantic::overload_resolve::callable_accepts_args;
 use crate::{
     AsyncState, CacheEntry, DbIndex, InFiled, LuaFunctionType, LuaGenericType, LuaInstanceType,
     LuaIntersectionType, LuaOperatorMetaMethod, LuaOperatorOwner, LuaSemanticDeclId, LuaSignature,
@@ -18,9 +16,11 @@ use crate::{
 use crate::{
     InferGuardRef,
     semantic::{
-        generic::TypeSubstitutor, infer::narrow::get_type_at_call_expr_inline_cast,
-        infer_node_semantic_decl, member::find_member_origin_owner,
-        overload_resolve::collect_callable_overload_groups,
+        generic::TypeSubstitutor,
+        infer::narrow::get_type_at_call_expr_inline_cast,
+        infer_node_semantic_decl,
+        member::find_member_origin_owner,
+        overload_resolve::{collect_callable_overload_groups, match_callable_by_arg_types},
     },
 };
 use crate::{build_self_type, infer_call_generic, infer_self_type, semantic::infer_expr};
@@ -236,13 +236,12 @@ fn infer_doc_function(
     Ok(func.clone().into())
 }
 
-fn filter_callable_overloads_by_call_args(
+fn filter_callable_overloads_by_args(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     overloads: Vec<Arc<LuaFunctionType>>,
     call_expr: &LuaCallExpr,
     args_count: Option<usize>,
-    strict_arg_filter: bool,
 ) -> Result<Vec<Arc<LuaFunctionType>>, InferFailReason> {
     let args = call_expr.get_args_list().ok_or(InferFailReason::None)?;
     let expr_types = super::infer_expr_list_types(
@@ -255,35 +254,11 @@ fn filter_callable_overloads_by_call_args(
     .into_iter()
     .map(|(ty, _)| ty)
     .collect::<Vec<_>>();
-    let is_colon_call = call_expr.is_colon_call();
 
     Ok(overloads
         .into_iter()
-        .filter(|func| {
-            let callable_tpls = func
-                .get_generic_params()
-                .iter()
-                .map(|generic_tpl| generic_tpl.get_tpl_id())
-                .collect::<HashSet<_>>();
-
-            if callable_tpls.is_empty() && !strict_arg_filter {
-                return true;
-            }
-
-            let has_tpls = !callable_tpls.is_empty();
-            let mut substitutor = TypeSubstitutor::new();
-            substitutor.add_need_infer_tpls(callable_tpls);
-            let match_func = if has_tpls {
-                let func_type = LuaType::DocFunction(func.clone());
-                match instantiate_type_generic(db, &func_type, &substitutor) {
-                    LuaType::DocFunction(doc_func) => doc_func,
-                    _ => func.clone(),
-                }
-            } else {
-                func.clone()
-            };
-
-            callable_accepts_args(db, &match_func, &expr_types, is_colon_call, args_count)
+        .filter_map(|func| {
+            match_callable_by_arg_types(db, cache, func, &expr_types, call_expr, args_count, true)
         })
         .collect())
 }
@@ -542,13 +517,12 @@ fn infer_union(
         let mut overload_groups = Vec::new();
         collect_callable_overload_groups(db, &ty, &mut overload_groups)?;
         for overloads in overload_groups {
-            let compatible_overloads = filter_callable_overloads_by_call_args(
+            let compatible_overloads = filter_callable_overloads_by_args(
                 db,
                 cache,
                 overloads.clone(),
                 &call_expr,
                 args_count,
-                true,
             )?;
             if compatible_overloads.is_empty() {
                 fallback_overloads.extend(overloads);
@@ -586,14 +560,6 @@ fn infer_union(
     let Some(first_func) = first_func else {
         if !fallback_overloads.is_empty() {
             let contains_tpl = fallback_overloads.iter().any(|func| func.contain_tpl());
-            let fallback_overloads = filter_callable_overloads_by_call_args(
-                db,
-                cache,
-                fallback_overloads,
-                &call_expr,
-                args_count,
-                false,
-            )?;
             return resolve_signature(
                 db,
                 cache,

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -60,8 +60,10 @@ pub(crate) use infer::try_infer_expr_for_index;
 pub(crate) use infer::{infer_expr, try_infer_expr_no_flow};
 use overload_resolve::resolve_signature;
 pub(crate) use overload_resolve::{
-    callable_accepts_args, collect_callable_overload_groups, get_func_param_type,
-    is_func_last_param_variadic,
+    callable_accepts_args, get_func_param_type, is_func_last_param_variadic,
+};
+pub use overload_resolve::{
+    collect_callable_overload_groups, filter_callable_overloads, find_callable_overload,
 };
 pub use semantic_info::SemanticDeclLevel;
 pub use type_check::{TypeCheckFailReason, TypeCheckResult};

crates/emmylua_code_analysis/src/semantic/overload_resolve/collect_overloads.rs

@@ -10,7 +10,7 @@ use crate::{
     },
 };
 
-pub(crate) fn collect_callable_overload_groups(
+pub fn collect_callable_overload_groups(
     db: &DbIndex,
     callable_type: &LuaType,
     groups: &mut Vec<Vec<Arc<LuaFunctionType>>>,

crates/emmylua_code_analysis/src/semantic/overload_resolve/filter_overloads.rs

@@ -0,0 +1,102 @@
+use std::sync::Arc;
+
+use emmylua_parser::LuaCallExpr;
+
+use crate::{
+    DbIndex, LuaFunctionType, LuaType,
+    semantic::{LuaInferCache, generic::infer_call_generic, infer::InferFailReason},
+};
+
+use super::{
+    collect_overloads::collect_callable_overload_groups,
+    resolve_signature_by_args::callable_accepts_args,
+};
+
+pub fn filter_callable_overloads(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    callable_type: &LuaType,
+    call_arg_types: &[LuaType],
+    call_expr: &LuaCallExpr,
+    args_count: Option<usize>,
+    return_instantiated_generic: bool,
+) -> Result<Vec<Arc<LuaFunctionType>>, InferFailReason> {
+    let mut overload_groups = Vec::new();
+    collect_callable_overload_groups(db, callable_type, &mut overload_groups)?;
+
+    Ok(overload_groups
+        .into_iter()
+        .flatten()
+        .filter_map(|func| {
+            match_callable_by_arg_types(
+                db,
+                cache,
+                func,
+                call_arg_types,
+                call_expr,
+                args_count,
+                return_instantiated_generic,
+            )
+        })
+        .collect())
+}
+
+pub fn find_callable_overload(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    callable_type: &LuaType,
+    call_arg_types: &[LuaType],
+    call_expr: &LuaCallExpr,
+    args_count: Option<usize>,
+    return_instantiated_generic: bool,
+) -> Result<Option<Arc<LuaFunctionType>>, InferFailReason> {
+    let mut overload_groups = Vec::new();
+    collect_callable_overload_groups(db, callable_type, &mut overload_groups)?;
+
+    Ok(overload_groups.into_iter().flatten().find_map(|func| {
+        match_callable_by_arg_types(
+            db,
+            cache,
+            func,
+            call_arg_types,
+            call_expr,
+            args_count,
+            return_instantiated_generic,
+        )
+    }))
+}
+
+pub(crate) fn match_callable_by_arg_types(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    func: Arc<LuaFunctionType>,
+    call_arg_types: &[LuaType],
+    call_expr: &LuaCallExpr,
+    args_count: Option<usize>,
+    return_instantiated_generic: bool,
+) -> Option<Arc<LuaFunctionType>> {
+    let has_tpls = func.contain_tpl();
+    let match_func = if has_tpls {
+        infer_call_generic(db, cache, func.as_ref(), call_expr.clone())
+            .map(Arc::new)
+            .unwrap_or_else(|_| func.clone())
+    } else {
+        func.clone()
+    };
+
+    if !callable_accepts_args(
+        db,
+        &match_func,
+        call_arg_types,
+        call_expr.is_colon_call(),
+        args_count,
+    ) {
+        return None;
+    }
+
+    if has_tpls && return_instantiated_generic {
+        Some(match_func)
+    } else {
+        Some(func)
+    }
+}

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

@@ -1,4 +1,5 @@
 mod collect_overloads;
+mod filter_overloads;
 mod resolve_signature_by_args;
 
 use std::sync::Arc;
@@ -13,7 +14,9 @@ use super::{
     infer::{InferCallFuncResult, InferFailReason, infer_expr_list_types, try_infer_expr_no_flow},
 };
 
-pub(crate) use collect_overloads::collect_callable_overload_groups;
+pub use collect_overloads::collect_callable_overload_groups;
+pub(crate) use filter_overloads::match_callable_by_arg_types;
+pub use filter_overloads::{filter_callable_overloads, find_callable_overload};
 pub(crate) use resolve_signature_by_args::{
     callable_accepts_args, get_func_param_type, is_func_last_param_variadic,
     resolve_signature_by_args,

crates/emmylua_ls/src/handlers/hover/function/call_hover.rs

@@ -1,14 +1,12 @@
-use std::{collections::HashSet, sync::Arc};
+use std::sync::Arc;
 
-use emmylua_code_analysis::{
-    DbIndex, LuaFunctionType, LuaType, LuaTypeDeclId, TypeSubstitutor, infer_call_generic,
-};
+use emmylua_code_analysis::{DbIndex, LuaFunctionType, LuaType, find_callable_overload};
 use emmylua_parser::LuaCallExpr;
 
 use crate::handlers::hover::{HoverBuilder, HoverDeclContext, HoverDeclInfo};
 
 use super::{
-    define_hover::{HoverFunctionInfo, set_builder_contents},
+    define_hover::{HoverFunctionInfo, set_function_info_to_builder},
     extract_function_member, get_function_description,
     render::process_function_type,
 };
@@ -34,7 +32,7 @@ pub(super) fn build_function_call_hover(
             }
         }
 
-        return set_builder_contents(builder, &mut function_infos);
+        return set_function_info_to_builder(builder, &mut function_infos);
     }
 
     for matched_decl in matched_decls {
@@ -44,7 +42,7 @@ pub(super) fn build_function_call_hover(
         }
     }
 
-    set_builder_contents(builder, &mut function_infos)
+    set_function_info_to_builder(builder, &mut function_infos)
 }
 
 fn infer_call_arg_types(builder: &HoverBuilder, call_expr: &LuaCallExpr) -> Vec<LuaType> {
@@ -138,87 +136,15 @@ fn find_callable_for_call(
     call_arg_types: &[LuaType],
     call_expr: &LuaCallExpr,
 ) -> Option<Arc<LuaFunctionType>> {
-    let mut overloads = Vec::new();
-    let mut visiting_aliases = HashSet::new();
-    collect_callable_functions(db, decl_type, &mut overloads, &mut visiting_aliases);
-
-    overloads.into_iter().find_map(|func| {
-        let func = if func.contain_tpl() {
-            infer_call_generic(
-                db,
-                &mut builder.semantic_model.get_cache().borrow_mut(),
-                func.as_ref(),
-                call_expr.clone(),
-            )
-            .map(Arc::new)
-            .unwrap_or(func)
-        } else {
-            func
-        };
-
-        builder
-            .semantic_model
-            .callable_accepts_args(
-                func.as_ref(),
-                call_arg_types,
-                call_expr.is_colon_call(),
-                None,
-            )
-            .then_some(func)
-    })
-}
-
-fn collect_callable_functions(
-    db: &DbIndex,
-    typ: &LuaType,
-    overloads: &mut Vec<Arc<LuaFunctionType>>,
-    visiting_aliases: &mut HashSet<LuaTypeDeclId>,
-) {
-    match typ {
-        LuaType::Ref(type_id) | LuaType::Def(type_id) => {
-            let Some(type_decl) = db.get_type_index().get_type_decl(type_id) else {
-                return;
-            };
-            if !visiting_aliases.insert(type_id.clone()) {
-                return;
-            }
-
-            if let Some(origin_type) = type_decl.get_alias_origin(db, None) {
-                collect_callable_functions(db, &origin_type, overloads, visiting_aliases);
-            }
-            visiting_aliases.remove(type_id);
-        }
-        LuaType::Generic(generic) => {
-            let type_id = generic.get_base_type_id();
-            let substitutor = TypeSubstitutor::from_type_array(generic.get_params().clone());
-            if !visiting_aliases.insert(type_id.clone()) {
-                return;
-            }
-
-            if let Some(type_decl) = db.get_type_index().get_type_decl(&type_id)
-                && let Some(origin_type) = type_decl.get_alias_origin(db, Some(&substitutor))
-            {
-                collect_callable_functions(db, &origin_type, overloads, visiting_aliases);
-            }
-            visiting_aliases.remove(&type_id);
-        }
-        LuaType::Union(union) => {
-            for member in union.into_vec() {
-                collect_callable_functions(db, &member, overloads, visiting_aliases);
-            }
-        }
-        LuaType::Intersection(intersection) => {
-            for member in intersection.get_types() {
-                collect_callable_functions(db, member, overloads, visiting_aliases);
-            }
-        }
-        LuaType::DocFunction(func) => overloads.push(func.clone()),
-        LuaType::Signature(signature_id) => {
-            if let Some(signature) = db.get_signature_index().get(signature_id) {
-                overloads.extend(signature.overloads.iter().cloned());
-                overloads.push(signature.to_doc_func_type());
-            }
-        }
-        _ => {}
-    }
+    find_callable_overload(
+        db,
+        &mut builder.semantic_model.get_cache().borrow_mut(),
+        decl_type,
+        call_arg_types,
+        call_expr,
+        None,
+        true,
+    )
+    .ok()
+    .flatten()
 }