Merge pull request #115 from xuhuanzy/hover

hover

Author: CppCXY

crates/emmylua_code_analysis/src/db_index/type/types.rs

@@ -481,6 +481,12 @@ impl LuaFunctionType {
             .any(|(_, t)| t.as_ref().map_or(false, |t| t.contain_tpl()))
             || self.ret.iter().any(|t| t.contain_tpl())
     }
+
+    pub fn first_param_is_self(&self) -> bool {
+        self.params.first().map_or(false, |(_, t)| {
+            t.as_ref().map_or(false, |t| t.is_self_infer())
+        })
+    }
 }
 
 impl From<LuaFunctionType> for LuaType {

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

@@ -4,7 +4,7 @@ use emmylua_parser::LuaCallExpr;
 
 use crate::{
     DbIndex, LuaFunctionType, LuaGenericType, LuaOperatorMetaMethod, LuaSignatureId, LuaType,
-    LuaTypeDeclId,
+    LuaTypeDeclId, LuaUnionType,
 };
 
 use super::{
@@ -53,10 +53,44 @@ pub fn infer_call_expr_func(
             infer_guard,
             args_count,
         ),
+        LuaType::Union(union) => {
+            // 此时我们将其视为泛型实例化联合体
+            if union.get_types().len() > 1
+                && union
+                    .get_types()
+                    .iter()
+                    .all(|t| matches!(t, LuaType::DocFunction(_)))
+            {
+                infer_generic_doc_function_union(db, config, &union, call_expr, args_count)
+            } else {
+                None
+            }
+        }
         _ => return None,
     }
 }
 
+fn infer_generic_doc_function_union(
+    db: &DbIndex,
+    config: &mut LuaInferConfig,
+    union: &LuaUnionType,
+    call_expr: LuaCallExpr,
+    args_count: Option<usize>,
+) -> Option<Arc<LuaFunctionType>> {
+    let overloads = union
+        .get_types()
+        .iter()
+        .filter_map(|typ| match typ {
+            LuaType::DocFunction(f) => Some(f.clone()),
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+
+    let doc_func = resolve_signature(db, config, overloads, call_expr.clone(), false, args_count)?;
+
+    Some(doc_func)
+}
+
 fn infer_signature_doc_function(
     db: &DbIndex,
     config: &mut LuaInferConfig,
@@ -74,7 +108,8 @@ fn infer_signature_doc_function(
             vec![],
         );
         if signature.is_generic() {
-            fake_doc_function = instantiate_func_generic(db, config, &fake_doc_function, call_expr)?;
+            fake_doc_function =
+                instantiate_func_generic(db, config, &fake_doc_function, call_expr)?;
         }
 
         Some(fake_doc_function.into())

crates/emmylua_code_analysis/src/semantic/instantiate/instantiate_class_generic.rs

@@ -308,27 +308,42 @@ fn instantiate_signature(
     substitutor: &TypeSubstitutor,
 ) -> LuaType {
     if let Some(signature) = db.get_signature_index().get(&signature_id) {
-        let rets = signature
-            .return_docs
-            .iter()
-            .map(|ret| ret.type_ref.clone())
-            .collect();
-        let is_async = if let Some(property) = db
-            .get_property_index()
-            .get_property(LuaPropertyOwnerId::Signature(signature_id.clone()))
-        {
-            property.is_async
-        } else {
-            false
+        let origin_type = {
+            let rets = signature
+                .return_docs
+                .iter()
+                .map(|ret| ret.type_ref.clone())
+                .collect();
+            let is_async = if let Some(property) = db
+                .get_property_index()
+                .get_property(LuaPropertyOwnerId::Signature(signature_id.clone()))
+            {
+                property.is_async
+            } else {
+                false
+            };
+            let fake_doc_function = LuaFunctionType::new(
+                is_async,
+                signature.is_colon_define,
+                signature.get_type_params(),
+                rets,
+            );
+            instantiate_doc_function(db, &fake_doc_function, substitutor)
         };
-        let fake_doc_function = LuaFunctionType::new(
-            is_async,
-            signature.is_colon_define,
-            signature.get_type_params(),
-            rets,
-        );
-        let instantiate_func = instantiate_doc_function(db, &fake_doc_function, substitutor);
-        return instantiate_func;
+        if signature.overloads.is_empty() {
+            return origin_type;
+        } else {
+            let mut result = Vec::new();
+            for overload in signature.overloads.iter() {
+                result.push(instantiate_doc_function(
+                    db,
+                    &(*overload).clone(),
+                    substitutor,
+                ));
+            }
+            result.push(origin_type); // 我们需要将原始类型放到最后
+            return LuaType::Union(LuaUnionType::new(result).into());
+        }
     }
 
     return LuaType::Signature(signature_id.clone());

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

@@ -22,7 +22,6 @@ pub fn resolve_signature(
     for arg in args.get_args() {
         expr_types.push(infer_expr(db, infer_config, arg)?);
     }
-
     if is_generic {
         return resolve_signature_by_generic(
             db,
@@ -33,7 +32,13 @@ pub fn resolve_signature(
             arg_count,
         );
     } else {
-        return resolve_signature_by_args(db, overloads, expr_types, arg_count);
+        return resolve_signature_by_args(
+            db,
+            overloads,
+            expr_types,
+            call_expr.is_colon_call(),
+            arg_count,
+        );
     }
 }
 
@@ -45,11 +50,12 @@ fn resolve_signature_by_generic(
     expr_types: Vec<LuaType>,
     arg_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
-    let mut max_match = -1;
+    let mut max_match: usize = 0;
     let mut matched_func: Option<Arc<LuaFunctionType>> = None;
     let mut instantiate_funcs = Vec::new();
     for func in overloads {
-        let instantiate_func = instantiate_func_generic(db, infer_config, &func, call_expr.clone())?;
+        let instantiate_func =
+            instantiate_func_generic(db, infer_config, &func, call_expr.clone())?;
         instantiate_funcs.push(Arc::new(instantiate_func));
     }
 
@@ -80,7 +86,7 @@ fn resolve_signature_by_generic(
     }
 
     if matched_func.is_none() && !instantiate_funcs.is_empty() {
-        matched_func = Some(instantiate_funcs[0].clone());
+        matched_func = Some(instantiate_funcs.last().cloned().unwrap());
     }
 
     matched_func
@@ -90,40 +96,56 @@ fn resolve_signature_by_args(
     db: &DbIndex,
     overloads: Vec<Arc<LuaFunctionType>>,
     expr_types: Vec<LuaType>,
+    is_colon_call: bool,
     arg_count: Option<usize>,
 ) -> Option<Arc<LuaFunctionType>> {
-    let mut max_match = -1;
+    let mut max_match: i32 = -1;
     let mut matched_func: Option<Arc<LuaFunctionType>> = None;
 
     for func in &overloads {
         let params = func.get_params();
-        let mut match_count = 0;
+        // 参数数量不足
         if params.len() < arg_count.unwrap_or(0) {
             continue;
         }
 
+        // 冒号调用但不是冒号定义的函数, 需要检查第一个参数是否为`self`
+        let jump_param = if is_colon_call && !func.is_colon_define() {
+            match params.get(0).and_then(|p| p.1.as_ref()) {
+                Some(param_type) if param_type == &LuaType::SelfInfer => 1,
+                Some(_) => break, // 不是冒号定义的函数, 但是是冒号调用
+                None => 0,
+            }
+        } else {
+            0
+        };
+
+        let mut match_count = 0;
+
         for (i, param) in params.iter().enumerate() {
-            if i >= expr_types.len() {
+            if expr_types.len() <= i - jump_param {
                 break;
             }
+            if i == 0 && jump_param > 0 {
+                continue;
+            }
 
             let param_type = param.1.clone().unwrap_or(LuaType::Any);
-            let expr_type = &expr_types[i];
-            if param_type == LuaType::Any {
-                match_count += 1;
-            } else if check_type_compact(db, &param_type, expr_type).is_ok() {
+            let expr_type = &expr_types[i - jump_param];
+            if param_type == LuaType::Any || check_type_compact(db, &param_type, expr_type).is_ok()
+            {
                 match_count += 1;
             }
         }
+
         if match_count > max_match {
             max_match = match_count;
             matched_func = Some(func.clone());
+            if match_count == (params.len() - jump_param) as i32 {
+                break;
+            }
         }
     }
 
-    if matched_func.is_none() && !overloads.is_empty() {
-        matched_func = Some(overloads[0].clone());
-    }
-
-    matched_func
+    matched_func.or_else(|| overloads.last().cloned())
 }

crates/emmylua_ls/src/handlers/hover/build_hover.rs

@@ -59,51 +59,38 @@ pub fn build_hover_content<'a>(
     db: &DbIndex,
     typ: Option<LuaType>,
     property_id: LuaPropertyOwnerId,
-    is_completion: bool, // 是否补全
+    is_completion: bool,
     token: Option<LuaSyntaxToken>,
 ) -> Option<HoverBuilder<'a>> {
+    let semantic_model = semantic_model?;
+    let mut builder = HoverBuilder::new(semantic_model, token, is_completion);
     match property_id {
         LuaPropertyOwnerId::LuaDecl(decl_id) => {
-            if let Some(semantic_model) = semantic_model {
-                let mut builder = HoverBuilder::new(semantic_model, token, is_completion);
-                if let Some(typ) = typ {
-                    build_decl_hover(&mut builder, db, typ, decl_id);
-                } else {
+            let effective_typ = match typ {
+                Some(t) => t,
+                None => {
                     let decl = db.get_decl_index().get_decl(&decl_id)?;
-                    let typ = decl.get_type()?;
-                    build_decl_hover(&mut builder, db, typ.clone(), decl_id);
+                    decl.get_type()?.clone()
                 }
-                Some(builder)
-            } else {
-                None
-            }
+            };
+            build_decl_hover(&mut builder, db, effective_typ, decl_id);
         }
         LuaPropertyOwnerId::Member(member_id) => {
-            if let Some(semantic_model) = semantic_model {
-                let mut builder = HoverBuilder::new(semantic_model, token, is_completion);
-                if let Some(typ) = typ {
-                    build_member_hover(&mut builder, db, typ, member_id);
-                } else {
+            let effective_typ = match typ {
+                Some(t) => t,
+                None => {
                     let member = db.get_member_index().get_member(&member_id)?;
-                    let typ = member.get_decl_type();
-                    build_member_hover(&mut builder, db, typ.clone(), member_id);
+                    member.get_decl_type().clone()
                 }
-                Some(builder)
-            } else {
-                None
-            }
+            };
+            build_member_hover(&mut builder, db, effective_typ, member_id);
         }
         LuaPropertyOwnerId::TypeDecl(type_decl_id) => {
-            if let Some(semantic_model) = semantic_model {
-                let mut builder = HoverBuilder::new(semantic_model, token, is_completion);
-                build_type_decl_hover(&mut builder, db, type_decl_id);
-                Some(builder)
-            } else {
-                None
-            }
+            build_type_decl_hover(&mut builder, db, type_decl_id);
         }
-        _ => None,
+        _ => return None,
     }
+    Some(builder)
 }
 
 fn build_decl_hover(
@@ -200,7 +187,18 @@ fn build_member_hover(
 
     let mut function_member = None;
     let mut owner_decl = None;
-    if typ.is_function() {
+    if typ.is_function()
+        || match &typ {
+            LuaType::Union(union) => {
+                union.get_types().len() > 1
+                    && union
+                        .get_types()
+                        .iter()
+                        .all(|t| matches!(t, LuaType::DocFunction(_)))
+            }
+            _ => false,
+        }
+    {
         let property_owner = get_member_owner(&builder.semantic_model, member_id);
         match property_owner {
             Some(LuaPropertyOwnerId::Member(member_id)) => {
@@ -448,5 +446,3 @@ fn get_member_owner(
     }
     resolved_property_owner
 }
-
-

crates/emmylua_ls/src/handlers/hover/hover_builder.rs

@@ -117,12 +117,18 @@ impl<'a> HoverBuilder<'a> {
                 match call_expr.kind().into() {
                     LuaSyntaxKind::CallExpr => {
                         let call_expr = LuaCallExpr::cast(call_expr)?;
-                        let func = self.semantic_model.infer_call_expr_func(call_expr.clone(), None);
+                        let func = self
+                            .semantic_model
+                            .infer_call_expr_func(call_expr.clone(), None);
                         if let Some(func) = func {
                             // 确定参数量是否与当前输入的参数数量一致, 因为`infer_call_expr_func`必然返回一个有效的类型, 即使不是完全匹配的
                             let call_expr_args_count = call_expr.get_args_count();
-                            if let Some(call_expr_args_count) = call_expr_args_count {
+                            if let Some(mut call_expr_args_count) = call_expr_args_count {
                                 let func_params_count = func.get_params().len();
+                                if !func.is_colon_define() && call_expr.is_colon_call() {
+                                    // 不是冒号定义的函数, 但是是冒号调用
+                                    call_expr_args_count += 1;
+                                }
                                 if call_expr_args_count == func_params_count {
                                     return Some((*func).clone());
                                 }