organize hover

Author: xuhuanzy

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(
@@ -448,5 +435,3 @@ fn get_member_owner(
     }
     resolved_property_owner
 }
-
-

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

@@ -29,12 +29,15 @@ pub fn hover_function_type(
 ) {
     match typ {
         LuaType::Function => builder.set_type_description(format!("function {}()", func_name)),
-        LuaType::DocFunction(lua_func) => builder.set_type_description(hover_doc_function_type(
-            db,
-            &lua_func,
-            function_member,
-            func_name,
-        )),
+        LuaType::DocFunction(lua_func) => {
+            // 泛型时会将`Signature`转为`DocFunction`
+            builder.set_type_description(hover_doc_function_type(
+                db,
+                &lua_func,
+                function_member,
+                func_name,
+            ))
+        }
         LuaType::Signature(signature_id) => hover_signature_type(
             builder,
             db,
@@ -50,41 +53,64 @@ pub fn hover_function_type(
     }
 }
 
-#[allow(unused)]
+// 泛型时会将`Signature`转为`DocFunction`, 我们必须处理这种情况
 fn hover_doc_function_type(
     db: &DbIndex,
     lua_func: &LuaFunctionType,
     owner_member: Option<&LuaMember>,
     func_name: &str,
 ) -> String {
-    let async_prev = if lua_func.is_async() { "async " } else { "" };
-    let mut type_prev = "function ";
+    dbg!(&lua_func);
+    let async_label = if lua_func.is_async() { "async " } else { "" };
+    let mut type_label = "function ";
     // 有可能来源于类. 例如: `local add = class.add`, `add()`应被视为类方法
-    let full_func_name = if let Some(owner_member) = owner_member {
+    let full_name = if let Some(owner_member) = owner_member {
         let mut name = String::new();
         let parent_owner = owner_member.get_owner();
-        if let LuaMemberOwner::Type(ty) = &parent_owner {
+        if let LuaMemberOwner::Type(ty) = &parent_owner.clone() {
             name.push_str(ty.get_simple_name());
             if owner_member.is_field().is_some() {
-                type_prev = "(field) ";
+                type_label = "(field) ";
             }
         }
         match owner_member.get_decl_type() {
             LuaType::DocFunction(func) => {
                 if func.is_colon_define()
                     || func.get_params().first().and_then(|param| {
-                        param.1.as_ref().map(|ty| {
-                            param.0 == "self"
-                                && humanize_type(db, ty, RenderLevel::Normal) == "self"
-                        })
+                        param
+                            .1
+                            .as_ref()
+                            .map(|ty| param.0 == "self" && ty.is_self_infer())
                     }) == Some(true)
                 {
-                    type_prev = "(method) ";
+                    type_label = "(method) ";
                     name.push_str(":");
                 } else {
                     name.push_str(".");
                 }
             }
+            LuaType::Signature(signature_id) => {
+                let signature = db.get_signature_index().get(&signature_id);
+                if let Some(signature) = signature {
+                    if signature.is_colon_define
+                        || signature // @field 定义的`docfunction`会被视为`signature`, 因此这里也需要匹配以转换为`method`
+                            .get_type_params()
+                            .first()
+                            .and_then(|param| {
+                                param
+                                    .1
+                                    .as_ref()
+                                    .map(|ty| param.0 == "self" && ty.is_self_infer())
+                            })
+                            .is_some()
+                    {
+                        type_label = "(method) ";
+                        name.push_str(":");
+                    } else {
+                        name.push_str(".");
+                    }
+                }
+            }
             _ => {}
         }
         if let LuaMemberKey::Name(n) = owner_member.get_key() {
@@ -104,7 +130,7 @@ fn hover_doc_function_type(
             if index == 0
                 && param.1.is_some()
                 && name == "self"
-                && humanize_type(db, param.1.as_ref().unwrap(), RenderLevel::Normal) == "self"
+                && param.1.as_ref().unwrap().is_self_infer()
             {
                 "".to_string()
             } else if let Some(ty) = &param.1 {
@@ -117,34 +143,21 @@ fn hover_doc_function_type(
         .collect::<Vec<_>>()
         .join(", ");
 
-    let rets = lua_func.get_ret();
-
-    let mut result = String::new();
-    result.push_str(type_prev);
-    result.push_str(async_prev);
-    result.push_str(&full_func_name);
-    result.push_str("(");
-    result.push_str(params.as_str());
-    result.push_str(")");
-
-    if !rets.is_empty() {
-        result.push_str(" -> ");
-        if rets.len() > 1 {
-            result.push_str("(");
-        }
-        result.push_str(
-            &rets
-                .iter()
-                .map(|ty| humanize_type(db, ty, RenderLevel::Normal))
-                .collect::<Vec<_>>()
-                .join(", "),
-        );
-        if rets.len() > 1 {
-            result.push_str(")");
+    let rets = {
+        let rets = lua_func.get_ret();
+        if rets.is_empty() {
+            "".to_string()
+        } else {
+            format!(
+                " -> {}",
+                rets.iter()
+                    .map(|ty| humanize_type(db, ty, RenderLevel::Simple))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
         }
-    }
-
-    result
+    };
+    format_function_type(type_label, async_label, full_name, params, rets)
 }
 
 fn hover_signature_type(
@@ -155,6 +168,7 @@ fn hover_signature_type(
     func_name: &str,
 ) -> Option<()> {
     let signature = db.get_signature_index().get(&signature_id)?;
+    let call_signature = builder.get_call_signature();
 
     let mut type_label = "function ";
     // 有可能来源于类. 例如: `local add = class.add`, `add()`应被视为类定义的内容
@@ -198,24 +212,20 @@ fn hover_signature_type(
             .collect::<Vec<_>>()
             .join(", ");
         let rets = get_signature_rets_string(db, signature, builder.is_completion, None);
-        let mut result = String::new();
-        if type_label.starts_with("function") {
-            result.push_str(async_label);
-            result.push_str(type_label);
-        } else {
-            result.push_str(type_label);
-            result.push_str(async_label);
+        let result = format_function_type(type_label, async_label, full_name.clone(), params, rets);
+        // 由于 @field 定义的`docfunction`会被视为`signature`, 因此这里额外处理
+        if let Some(call_signature) = &call_signature {
+            if call_signature.get_params() == signature.get_type_params() {
+                // 如果具有完全匹配的签名, 那么将其设置为当前签名, 且不显示重载
+                builder.set_type_description(result);
+                builder.signature_overload = None;
+                return Some(());
+            }
         }
-        result.push_str(&full_name);
-        result.push_str("(");
-        result.push_str(params.as_str());
-        result.push_str(")");
-        result.push_str(rets.as_str());
         result
     };
     // 构建所有重载
     let overloads: Vec<String> = {
-        let call_signature = builder.get_call_signature();
         let mut overloads = Vec::new();
         for (_, overload) in signature.overloads.iter().enumerate() {
             let async_label = if overload.is_async() { "async " } else { "" };
@@ -234,20 +244,8 @@ fn hover_signature_type(
                 .join(", ");
             let rets =
                 get_signature_rets_string(db, signature, builder.is_completion, Some(overload));
-
-            let mut result = String::new();
-            if type_label.starts_with("function") {
-                result.push_str(async_label);
-                result.push_str(type_label);
-            } else {
-                result.push_str(type_label);
-                result.push_str(async_label);
-            }
-            result.push_str(&full_name);
-            result.push_str("(");
-            result.push_str(params.as_str());
-            result.push_str(")");
-            result.push_str(rets.as_str());
+            let result =
+                format_function_type(type_label, async_label, full_name.clone(), params, rets);
 
             if let Some(call_signature) = &call_signature {
                 if *call_signature == **overload {
@@ -298,13 +296,17 @@ fn get_signature_rets_string(
             overload_rets_string
         } else {
             let rets = &signature.return_docs;
-            format!(
-                " -> {}",
-                rets.iter()
-                    .map(|ret| humanize_type(db, &ret.type_ref, RenderLevel::Simple))
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            )
+            if rets.is_empty() {
+                "".to_string()
+            } else {
+                format!(
+                    " -> {}",
+                    rets.iter()
+                        .map(|ret| humanize_type(db, &ret.type_ref, RenderLevel::Simple))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
         };
         result.push_str(rets.as_str());
     } else {
@@ -351,3 +353,18 @@ fn get_signature_rets_string(
     };
     result
 }
+
+fn format_function_type(
+    type_label: &str,
+    async_label: &str,
+    full_name: String,
+    params: String,
+    rets: String,
+) -> String {
+    let prefix = if type_label.starts_with("function") {
+        format!("{}{}", async_label, type_label)
+    } else {
+        format!("{}{}", type_label, async_label)
+    };
+    format!("{}{}({}){}", prefix, full_name, params, rets)
+}