optimize inlay_hint: closure params 现在可以跳转到实际类型定义处

xuhuanzy · xuhuanzy · commit 86ca4dd7eab1 · 2025-06-13T03:19:35.000+08:00
diff --git a/crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs b/crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs
@@ -1,5 +1,7 @@
 use std::collections::HashSet;
 
+use itertools::Itertools;
+
 use crate::{
     DbIndex, GenericTpl, LuaAliasCallType, LuaFunctionType, LuaGenericType, LuaInstanceType,
     LuaIntersectionType, LuaMemberKey, LuaMemberOwner, LuaObjectType, LuaSignatureId,
@@ -404,9 +406,11 @@ fn humanize_object_type(db: &DbIndex, object: &LuaObjectType, level: RenderLevel
     } else {
         ""
     };
+
     let fields = object
         .get_fields()
         .iter()
+        .sorted_by(|a, b| a.0.cmp(&b.0))
         .take(num)
         .map(|field| {
             let name = field.0.clone();
@@ -419,7 +423,7 @@ fn humanize_object_type(db: &DbIndex, object: &LuaObjectType, level: RenderLevel
             }
         })
         .collect::<Vec<_>>()
-        .join(",");
+        .join(", ");
 
     let access = object
         .get_index_access()
diff --git a/crates/emmylua_ls/src/handlers/hover/mod.rs b/crates/emmylua_ls/src/handlers/hover/mod.rs
@@ -10,7 +10,7 @@ pub use build_hover::build_hover_content_for_completion;
 use build_hover::build_semantic_info_hover;
 use emmylua_code_analysis::{EmmyLuaAnalysis, FileId};
 use emmylua_parser::LuaAstNode;
-pub use find_origin::{find_member_origin_owner, find_all_same_named_members};
+pub use find_origin::{find_all_same_named_members, find_member_origin_owner};
 pub use hover_builder::HoverBuilder;
 pub use hover_humanize::infer_prefix_global_name;
 use keyword_hover::{hover_keyword, is_keyword};
diff --git a/crates/emmylua_ls/src/handlers/inlay_hint/build_function_hint.rs b/crates/emmylua_ls/src/handlers/inlay_hint/build_function_hint.rs
@@ -0,0 +1,180 @@
+use std::collections::HashMap;
+
+use emmylua_code_analysis::{humanize_type, LuaSignatureId, LuaType, RenderLevel, SemanticModel};
+use emmylua_parser::{LuaAstNode, LuaClosureExpr};
+use itertools::Itertools;
+use lsp_types::{InlayHint, InlayHintKind, InlayHintLabel, InlayHintLabelPart, Location};
+
+pub fn build_closure_hint(
+    semantic_model: &SemanticModel,
+    result: &mut Vec<InlayHint>,
+    closure: LuaClosureExpr,
+) -> Option<()> {
+    if !semantic_model.get_emmyrc().hint.param_hint {
+        return Some(());
+    }
+    let file_id = semantic_model.get_file_id();
+    let signature_id = LuaSignatureId::from_closure(file_id, &closure);
+    let signature = semantic_model
+        .get_db()
+        .get_signature_index()
+        .get(&signature_id)?;
+
+    let lua_params = closure.get_params_list()?;
+    let signature_params = signature.get_type_params();
+    let mut lua_params_map = HashMap::new();
+    for param in lua_params.get_params() {
+        if let Some(name_token) = param.get_name_token() {
+            let name = name_token.get_name_text().to_string();
+            lua_params_map.insert(name, param);
+        } else if param.is_dots() {
+            lua_params_map.insert("...".to_string(), param);
+        }
+    }
+
+    let document = semantic_model.get_document();
+    for (signature_param_name, typ) in &signature_params {
+        if let Some(typ) = typ {
+            if typ.is_any() {
+                continue;
+            }
+
+            if let Some(lua_param) = lua_params_map.get(signature_param_name) {
+                let lsp_range = document.to_lsp_range(lua_param.get_range())?;
+                // 构造 label
+                let mut label_parts = build_label_parts(semantic_model, &typ);
+                // 为空时添加默认值
+                if label_parts.is_empty() {
+                    let typ_desc = format!(
+                        ": {}",
+                        humanize_type(semantic_model.get_db(), &typ, RenderLevel::Simple)
+                    );
+                    label_parts.push(InlayHintLabelPart {
+                        value: typ_desc,
+                        location: Some(
+                            get_type_location(semantic_model, typ)
+                                .unwrap_or(Location::new(document.get_uri(), lsp_range)),
+                        ),
+                        ..Default::default()
+                    });
+                }
+                let hint = InlayHint {
+                    kind: Some(InlayHintKind::TYPE),
+                    label: InlayHintLabel::LabelParts(label_parts),
+                    position: lsp_range.end,
+                    text_edits: None,
+                    tooltip: None,
+                    padding_left: Some(true),
+                    padding_right: None,
+                    data: None,
+                };
+                result.push(hint);
+            }
+        }
+    }
+
+    Some(())
+}
+
+fn build_label_parts(semantic_model: &SemanticModel, typ: &LuaType) -> Vec<InlayHintLabelPart> {
+    let mut parts: Vec<InlayHintLabelPart> = Vec::new();
+    match typ {
+        LuaType::Union(union) => {
+            for typ in union.get_types() {
+                if let Some(part) = get_part(semantic_model, typ) {
+                    parts.push(part);
+                }
+            }
+        }
+        _ => {
+            if let Some(part) = get_part(semantic_model, typ) {
+                parts.push(part);
+            }
+        }
+    }
+    // 去重
+    let parts: Vec<InlayHintLabelPart> = parts
+        .into_iter()
+        .unique_by(|part| part.value.clone())
+        .collect();
+    // 将 "?" 标签移到最后
+    let mut normal_parts = Vec::new();
+    let mut nil_parts = Vec::new();
+    for part in parts {
+        if part.value == "?" {
+            nil_parts.push(part);
+        } else {
+            normal_parts.push(part);
+        }
+    }
+    normal_parts.append(&mut nil_parts);
+    let mut result = Vec::new();
+    for (i, part) in normal_parts.into_iter().enumerate() {
+        let mut part = part;
+        if part.value != "?" {
+            part.value = format!("{}{}", if i == 0 { ": " } else { "|" }, part.value);
+        }
+        result.push(part);
+    }
+    result
+}
+
+fn get_part(semantic_model: &SemanticModel, typ: &LuaType) -> Option<InlayHintLabelPart> {
+    match typ {
+        LuaType::Union(_) => None,
+        LuaType::Nil => {
+            return Some(InlayHintLabelPart {
+                value: "?".to_string(),
+                location: get_type_location(semantic_model, typ),
+                ..Default::default()
+            });
+        }
+        _ => {
+            let value = humanize_type(semantic_model.get_db(), typ, RenderLevel::Simple);
+            let location = get_type_location(semantic_model, typ);
+            return Some(InlayHintLabelPart {
+                value,
+                location,
+                ..Default::default()
+            });
+        }
+    }
+}
+
+fn get_type_location(semantic_model: &SemanticModel, typ: &LuaType) -> Option<Location> {
+    match typ {
+        LuaType::Ref(id) => {
+            let type_decl = semantic_model
+                .get_db()
+                .get_type_index()
+                .get_type_decl(&id)?;
+            let location = type_decl.get_locations().first()?;
+            let document = semantic_model.get_document_by_file_id(location.file_id)?;
+            let lsp_range = document.to_lsp_range(location.range)?;
+            Some(Location::new(document.get_uri(), lsp_range))
+        }
+        LuaType::Any => get_base_type_location(semantic_model, "any"),
+        LuaType::Nil => get_base_type_location(semantic_model, "nil"),
+        LuaType::Unknown => get_base_type_location(semantic_model, "string"),
+        LuaType::Userdata => get_base_type_location(semantic_model, "userdata"),
+        LuaType::Function => get_base_type_location(semantic_model, "function"),
+        LuaType::Thread => get_base_type_location(semantic_model, "thread"),
+        LuaType::Table => get_base_type_location(semantic_model, "table"),
+        _ if typ.is_string() => get_base_type_location(semantic_model, "string"),
+        _ if typ.is_integer() => get_base_type_location(semantic_model, "integer"),
+        _ if typ.is_number() => get_base_type_location(semantic_model, "number"),
+        _ if typ.is_boolean() => get_base_type_location(semantic_model, "boolean"),
+        _ => None,
+    }
+}
+
+fn get_base_type_location(semantic_model: &SemanticModel, name: &str) -> Option<Location> {
+    let type_decl = semantic_model
+        .get_db()
+        .get_type_index()
+        .find_type_decl(semantic_model.get_file_id(), name)?;
+    let location = type_decl.get_locations().first()?;
+    let document = semantic_model.get_document_by_file_id(location.file_id)?;
+    let lsp_range = document.to_lsp_range(location.range)?;
+    Some(Location::new(document.get_uri(), lsp_range))
+}
diff --git a/crates/emmylua_ls/src/handlers/inlay_hint/build_inlay_hint.rs b/crates/emmylua_ls/src/handlers/inlay_hint/build_inlay_hint.rs
@@ -1,20 +1,22 @@
 use std::collections::HashMap;
 
 use emmylua_code_analysis::{
-    FileId, InferGuard, LuaFunctionType, LuaMemberId, LuaMemberKey, LuaSemanticDeclId,
-    LuaSignatureId, LuaType, RenderLevel, SemanticModel,
+    FileId, InferGuard, LuaFunctionType, LuaMemberId, LuaMemberKey, LuaSemanticDeclId, LuaType,
+    RenderLevel, SemanticModel,
 };
 use emmylua_parser::LuaTokenKind;
 use emmylua_parser::{
-    LuaAst, LuaAstNode, LuaCallExpr, LuaClosureExpr, LuaExpr, LuaFuncStat, LuaIndexExpr,
-    LuaLocalName, LuaStat, LuaSyntaxId, LuaVarExpr,
+    LuaAst, LuaAstNode, LuaCallExpr, LuaExpr, LuaFuncStat, LuaIndexExpr, LuaLocalName, LuaStat,
+    LuaSyntaxId, LuaVarExpr,
 };
 use lsp_types::{InlayHint, InlayHintKind, InlayHintLabel, InlayHintLabelPart, Location};
 use rowan::NodeOrToken;
 
 use emmylua_code_analysis::humanize_type;
 use rowan::TokenAtOffset;
 
+use crate::handlers::inlay_hint::build_function_hint::build_closure_hint;
+
 pub fn build_inlay_hints(semantic_model: &SemanticModel) -> Option<Vec<InlayHint>> {
     let mut result = Vec::new();
     let root = semantic_model.get_root();
@@ -40,66 +42,6 @@ pub fn build_inlay_hints(semantic_model: &SemanticModel) -> Option<Vec<InlayHint
     Some(result)
 }
 
-fn build_closure_hint(
-    semantic_model: &SemanticModel,
-    result: &mut Vec<InlayHint>,
-    closure: LuaClosureExpr,
-) -> Option<()> {
-    if !semantic_model.get_emmyrc().hint.param_hint {
-        return Some(());
-    }
-    let file_id = semantic_model.get_file_id();
-    let signature_id = LuaSignatureId::from_closure(file_id, &closure);
-    let signature = semantic_model
-        .get_db()
-        .get_signature_index()
-        .get(&signature_id)?;
-
-    let lua_params = closure.get_params_list()?;
-    let signature_params = signature.get_type_params();
-    let mut lua_params_map = HashMap::new();
-    for param in lua_params.get_params() {
-        if let Some(name_token) = param.get_name_token() {
-            let name = name_token.get_name_text().to_string();
-            lua_params_map.insert(name, param);
-        } else if param.is_dots() {
-            lua_params_map.insert("...".to_string(), param);
-        }
-    }
-
-    let document = semantic_model.get_document();
-    let db = semantic_model.get_db();
-    for (signature_param_name, typ) in &signature_params {
-        if let Some(typ) = typ {
-            if typ.is_any() {
-                continue;
-            }
-
-            if let Some(lua_param) = lua_params_map.get(signature_param_name) {
-                let lsp_range = document.to_lsp_range(lua_param.get_range())?;
-                let typ_desc = format!(": {}", humanize_type(db, &typ, RenderLevel::Simple));
-                let hint = InlayHint {
-                    kind: Some(InlayHintKind::TYPE),
-                    label: InlayHintLabel::LabelParts(vec![InlayHintLabelPart {
-                        value: typ_desc,
-                        location: Some(Location::new(document.get_uri(), lsp_range)),
-                        ..Default::default()
-                    }]),
-                    position: lsp_range.end,
-                    text_edits: None,
-                    tooltip: None,
-                    padding_left: Some(true),
-                    padding_right: None,
-                    data: None,
-                };
-                result.push(hint);
-            }
-        }
-    }
-
-    Some(())
-}
-
 fn build_call_expr_param_hint(
     semantic_model: &SemanticModel,
     result: &mut Vec<InlayHint>,
diff --git a/crates/emmylua_ls/src/handlers/inlay_hint/mod.rs b/crates/emmylua_ls/src/handlers/inlay_hint/mod.rs
@@ -1,6 +1,8 @@
+mod build_function_hint;
 mod build_inlay_hint;
 
 use build_inlay_hint::build_inlay_hints;
+use emmylua_code_analysis::{EmmyLuaAnalysis, FileId};
 use lsp_types::{
     ClientCapabilities, InlayHint, InlayHintOptions, InlayHintParams, InlayHintServerCapabilities,
     OneOf, ServerCapabilities,
@@ -18,7 +20,10 @@ pub async fn on_inlay_hint_handler(
 ) -> Option<Vec<InlayHint>> {
     let uri = params.text_document.uri;
     let analysis = context.analysis.read().await;
-    let file_id = analysis.get_file_id(&uri)?;
+    inlay_hint(&analysis, analysis.get_file_id(&uri)?)
+}
+
+pub fn inlay_hint(analysis: &EmmyLuaAnalysis, file_id: FileId) -> Option<Vec<InlayHint>> {
     let mut semantic_model = analysis.compilation.get_semantic_model(file_id)?;
     build_inlay_hints(&mut semantic_model)
 }
diff --git a/crates/emmylua_ls/src/handlers/test/inlay_hint_test.rs b/crates/emmylua_ls/src/handlers/test/inlay_hint_test.rs
@@ -0,0 +1,57 @@
+#[cfg(test)]
+mod tests {
+    use lsp_types::{InlayHint, InlayHintLabel, Location, Position, Range};
+
+    use crate::handlers::test_lib::ProviderVirtualWorkspace;
+
+    fn extract_first_label_part_location(inlay_hint: &InlayHint) -> Option<&Location> {
+        match &inlay_hint.label {
+            InlayHintLabel::LabelParts(parts) => parts.first()?.location.as_ref(),
+            InlayHintLabel::String(_) => None,
+        }
+    }
+
+    #[test]
+    fn test_1() {
+        let mut ws = ProviderVirtualWorkspace::new();
+        let result = ws
+            .check_inlay_hint(
+                r#"
+                ---@class Hint1
+    
+                ---@param a Hint1
+                local function test(a)
+                    local b = a
+                end
+            "#,
+            )
+            .unwrap();
+
+        let first = result.first().unwrap();
+        let location = extract_first_label_part_location(first).unwrap();
+
+        assert_eq!(
+            location.range,
+            Range::new(Position::new(1, 26), Position::new(1, 31))
+        );
+    }
+
+    #[test]
+    fn test_2() {
+        let mut ws = ProviderVirtualWorkspace::new_with_init_std_lib();
+        let result = ws
+            .check_inlay_hint(
+                r#"
+    
+                ---@param a number
+                local function test(a)
+                end
+            "#,
+            )
+            .unwrap();
+
+        let first = result.first().unwrap();
+        let location = extract_first_label_part_location(first).unwrap();
+        assert!(location.uri.path().as_str().ends_with("builtin.lua"));
+    }
+}
diff --git a/crates/emmylua_ls/src/handlers/test/mod.rs b/crates/emmylua_ls/src/handlers/test/mod.rs
@@ -4,4 +4,5 @@ mod definition_test;
 mod hover_function_test;
 mod hover_test;
 mod implementation_test;
+mod inlay_hint_test;
 mod signature_helper_test;
diff --git a/crates/emmylua_ls/src/handlers/test_lib/mod.rs b/crates/emmylua_ls/src/handlers/test_lib/mod.rs
