support custom request gutter detail for intellij

Author: CppCXY

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

@@ -188,6 +188,56 @@ impl LuaTypeIndex {
             .map(|supers| supers.iter().map(|s| &s.value))
     }
 
+    /// Get all direct subclasses of a given type
+    /// Returns a vector of type declarations that directly inherit from the given type
+    pub fn get_sub_types(&self, decl_id: &LuaTypeDeclId) -> Vec<&LuaTypeDecl> {
+        let mut sub_types = Vec::new();
+
+        // Iterate through all types and check their super types
+        for (type_id, supers) in &self.supers {
+            for super_filed in supers {
+                // Check if this super type references our target type
+                if let LuaType::Ref(super_id) = &super_filed.value {
+                    if super_id == decl_id {
+                        // Found a subclass
+                        if let Some(sub_decl) = self.full_name_type_map.get(type_id) {
+                            sub_types.push(sub_decl);
+                        }
+                        break; // No need to check other supers of this type
+                    }
+                }
+            }
+        }
+
+        sub_types
+    }
+
+    /// Get all subclasses (direct and indirect) of a given type recursively
+    /// Returns a vector of type declarations in the inheritance hierarchy
+    pub fn get_all_sub_types(&self, decl_id: &LuaTypeDeclId) -> Vec<&LuaTypeDecl> {
+        let mut all_sub_types = Vec::new();
+        let mut visited = HashSet::new();
+        let mut queue = vec![decl_id.clone()];
+
+        while let Some(current_id) = queue.pop() {
+            if !visited.insert(current_id.clone()) {
+                continue;
+            }
+
+            // Find direct subclasses of current_id
+            let direct_subs = self.get_sub_types(&current_id);
+            for sub_decl in direct_subs {
+                let sub_id = sub_decl.get_id();
+                if !visited.contains(&sub_id) {
+                    all_sub_types.push(sub_decl);
+                    queue.push(sub_id);
+                }
+            }
+        }
+
+        all_sub_types
+    }
+
     pub fn get_type_decl(&self, decl_id: &LuaTypeDeclId) -> Option<&LuaTypeDecl> {
         self.full_name_type_map.get(decl_id)
     }

crates/emmylua_ls/src/handlers/emmy_gutter/emmy_gutter_detail_request.rs

@@ -0,0 +1,30 @@
+use lsp_types::request::Request;
+use serde::{Deserialize, Serialize};
+
+use crate::handlers::emmy_gutter::GutterKind;
+
+#[derive(Debug)]
+pub enum EmmyGutterDetailRequest {}
+
+impl Request for EmmyGutterDetailRequest {
+    type Params = EmmyGutterDetailParams;
+    type Result = Option<GutterDetailResponse>;
+    const METHOD: &'static str = "emmy/gutter/detail";
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
+pub struct EmmyGutterDetailParams {
+    pub data: String,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
+pub struct GutterLocation {
+    pub uri: String,
+    pub line: i32,
+    pub kind: GutterKind,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
+pub struct GutterDetailResponse {
+    pub locations: Vec<GutterLocation>,
+}

crates/emmylua_ls/src/handlers/emmy_gutter/emmy_gutter_request.rs

@@ -15,20 +15,12 @@ pub struct EmmyGutterParams {
     pub uri: String,
 }
 
-// /**
-//  * Gutter information returned from LSP
-//  */
-// data class GutterInfo(
-//     val range: Range,
-//     val kind: GutterKind,
-//     val detail: String?
-// )
-
 #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
 pub struct GutterInfo {
     pub range: Range,
     pub kind: GutterKind,
     pub detail: Option<String>,
+    pub data: Option<String>,
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
@@ -39,6 +31,7 @@ pub enum GutterKind {
     Alias = 2,
     Method = 3,
     Module = 4,
+    Override = 5,
 }
 
 impl From<GutterKind> for u8 {
@@ -55,6 +48,7 @@ impl From<u8> for GutterKind {
             2 => GutterKind::Alias,
             3 => GutterKind::Method,
             4 => GutterKind::Module,
+            5 => GutterKind::Override,
             _ => GutterKind::Class, // default case
         }
     }

crates/emmylua_ls/src/handlers/emmy_gutter/mod.rs

@@ -1,14 +1,19 @@
+mod emmy_gutter_detail_request;
 mod emmy_gutter_request;
 
 use std::str::FromStr;
 
 use crate::{
     context::ServerContextSnapshot,
-    handlers::emmy_gutter::emmy_gutter_request::{EmmyGutterParams, GutterInfo},
+    handlers::{
+        emmy_gutter::emmy_gutter_request::{EmmyGutterParams, GutterInfo},
+        inlay_hint::{get_override_lsp_location, get_super_member_id},
+    },
 };
+pub use emmy_gutter_detail_request::*;
 pub use emmy_gutter_request::*;
-use emmylua_code_analysis::SemanticModel;
-use emmylua_parser::{LuaAstNode, LuaAstToken, LuaDocTag};
+use emmylua_code_analysis::{InferGuard, LuaMemberKey, LuaType, SemanticModel};
+use emmylua_parser::{LuaAst, LuaAstNode, LuaAstToken, LuaVarExpr};
 use lsp_types::Uri;
 use tokio_util::sync::CancellationToken;
 
@@ -29,38 +34,148 @@ fn build_gutter_infos(semantic_model: &SemanticModel) -> Option<Vec<GutterInfo>>
     let root = semantic_model.get_root().clone();
     let document = semantic_model.get_document();
     let mut gutters = Vec::new();
-    for tag in root.descendants::<LuaDocTag>() {
+    for tag in root.descendants::<LuaAst>() {
         match tag {
-            LuaDocTag::Alias(alias) => {
-                let range = alias.get_name_token()?.get_range();
+            LuaAst::LuaDocTagAlias(alias) => {
+                let name_token = alias.get_name_token()?;
+                let range = name_token.get_range();
+                let name = name_token.get_text();
                 let lsp_range = document.to_lsp_range(range)?;
                 gutters.push(GutterInfo {
                     range: lsp_range,
                     kind: GutterKind::Alias,
                     detail: Some("type alias".to_string()),
+                    data: Some(name.to_string()),
                 });
             }
-            LuaDocTag::Class(class) => {
-                let range = class.get_name_token()?.get_range();
+            LuaAst::LuaDocTagClass(class) => {
+                let name_token = class.get_name_token()?;
+                let range = name_token.get_range();
+                let name = name_token.get_text();
                 let lsp_range = document.to_lsp_range(range)?;
                 gutters.push(GutterInfo {
                     range: lsp_range,
                     kind: GutterKind::Class,
                     detail: Some("class".to_string()),
+                    data: Some(name.to_string()),
                 });
             }
-            LuaDocTag::Enum(enm) => {
+            LuaAst::LuaDocTagEnum(enm) => {
                 let range = enm.get_name_token()?.get_range();
                 let lsp_range = document.to_lsp_range(range)?;
                 gutters.push(GutterInfo {
                     range: lsp_range,
                     kind: GutterKind::Enum,
                     detail: Some("enum".to_string()),
+                    data: None,
                 });
             }
+            LuaAst::LuaFuncStat(func_stat) => {
+                build_func_override_gutter_info(semantic_model, &mut gutters, func_stat);
+            }
             _ => {}
         }
     }
 
     Some(gutters)
 }
+
+fn build_func_override_gutter_info(
+    semantic_model: &SemanticModel,
+    gutters: &mut Vec<GutterInfo>,
+    func_stat: emmylua_parser::LuaFuncStat,
+) -> Option<()> {
+    if !semantic_model.get_emmyrc().hint.override_hint {
+        return Some(());
+    }
+
+    let func_name = func_stat.get_func_name()?;
+    let func_name_pos = func_name.get_position();
+    if let LuaVarExpr::IndexExpr(index_expr) = func_name {
+        let prefix_expr = index_expr.get_prefix_expr()?;
+        let prefix_type = semantic_model.infer_expr(prefix_expr).ok()?;
+        if let LuaType::Def(id) = prefix_type {
+            let supers = semantic_model
+                .get_db()
+                .get_type_index()
+                .get_super_types(&id)?;
+
+            let index_key = index_expr.get_index_key()?;
+            let member_key: LuaMemberKey = semantic_model.get_member_key(&index_key)?;
+            let guard = InferGuard::new();
+            for super_type in supers {
+                if let Some(member_id) =
+                    get_super_member_id(semantic_model, super_type, &member_key, &guard)
+                {
+                    let member = semantic_model
+                        .get_db()
+                        .get_member_index()
+                        .get_member(&member_id)?;
+
+                    let document = semantic_model.get_document();
+                    let func_name_lsp_pos = document.to_lsp_position(func_name_pos)?;
+
+                    let file_id = member.get_file_id();
+                    let syntax_id = member.get_syntax_id();
+                    let lsp_location =
+                        get_override_lsp_location(semantic_model, file_id, syntax_id)?;
+                    let hint = GutterInfo {
+                        range: lsp_types::Range {
+                            start: func_name_lsp_pos,
+                            end: func_name_lsp_pos,
+                        },
+                        kind: GutterKind::Override,
+                        detail: Some("overrides method".to_string()),
+                        data: Some(format!(
+                            "{}#{}#{}",
+                            lsp_location.uri.get_file_path()?.display(),
+                            lsp_location.range.start.line,
+                            0
+                        )),
+                    };
+                    gutters.push(hint);
+                    break;
+                }
+            }
+        }
+    }
+
+    Some(())
+}
+
+pub async fn on_emmy_gutter_detail_handler(
+    context: ServerContextSnapshot,
+    params: EmmyGutterDetailParams,
+    _: CancellationToken,
+) -> Option<GutterDetailResponse> {
+    let type_name = params.data;
+    let analysis = context.analysis().read().await;
+    let db = &analysis.compilation.get_db();
+    let type_index = db.get_type_index();
+
+    // Find the type declaration
+    let type_id = emmylua_code_analysis::LuaTypeDeclId::new(&type_name);
+    type_index.get_type_decl(&type_id)?;
+
+    // Get all subclasses
+    let sub_types = type_index.get_all_sub_types(&type_id);
+
+    // Build locations from subclasses
+    let mut locations = Vec::new();
+    for sub_type in sub_types {
+        for location in sub_type.get_locations() {
+            let file_id = location.file_id;
+            if let Some(document) = db.get_vfs().get_document(&file_id) {
+                if let Some(lsp_range) = document.to_lsp_range(location.range) {
+                    locations.push(GutterLocation {
+                        uri: document.get_uri().to_string(),
+                        line: lsp_range.start.line as i32,
+                        kind: GutterKind::Class,
+                    });
+                }
+            }
+        }
+    }
+
+    Some(GutterDetailResponse { locations })
+}

crates/emmylua_ls/src/handlers/inlay_hint/build_inlay_hint.rs

@@ -17,11 +17,15 @@ use rowan::NodeOrToken;
 
 use rowan::TokenAtOffset;
 
+use crate::context::ClientId;
 use crate::handlers::completion::get_index_alias_name;
 use crate::handlers::definition::compare_function_types;
 use crate::handlers::inlay_hint::build_function_hint::{build_closure_hint, build_label_parts};
 
-pub fn build_inlay_hints(semantic_model: &SemanticModel) -> Option<Vec<InlayHint>> {
+pub fn build_inlay_hints(
+    semantic_model: &SemanticModel,
+    client_id: ClientId,
+) -> Option<Vec<InlayHint>> {
     let mut result = Vec::new();
     let root = semantic_model.get_root();
     for node in root.clone().descendants::<LuaAst>() {
@@ -39,6 +43,9 @@ pub fn build_inlay_hints(semantic_model: &SemanticModel) -> Option<Vec<InlayHint
                 build_local_name_hint(semantic_model, &mut result, local_name);
             }
             LuaAst::LuaFuncStat(func_stat) => {
+                if client_id.is_intellij() {
+                    continue;
+                }
                 build_func_stat_override_hint(semantic_model, &mut result, func_stat);
             }
             LuaAst::LuaIndexExpr(index_expr) => {
@@ -426,7 +433,7 @@ fn build_func_stat_override_hint(
     Some(())
 }
 
-fn get_super_member_id(
+pub fn get_super_member_id(
     semantic_model: &SemanticModel,
     super_type: LuaType,
     member_key: &LuaMemberKey,
@@ -449,7 +456,7 @@ fn get_super_member_id(
     None
 }
 
-fn get_override_lsp_location(
+pub fn get_override_lsp_location(
     semantic_model: &SemanticModel,
     file_id: FileId,
     syntax_id: LuaSyntaxId,

crates/emmylua_ls/src/handlers/inlay_hint/mod.rs

@@ -1,31 +1,40 @@
 mod build_function_hint;
 mod build_inlay_hint;
 
+use super::RegisterCapabilities;
+use crate::context::{ClientId, ServerContextSnapshot};
 use build_inlay_hint::build_inlay_hints;
+pub use build_inlay_hint::{get_override_lsp_location, get_super_member_id};
 use emmylua_code_analysis::{EmmyLuaAnalysis, FileId};
 use lsp_types::{
     ClientCapabilities, InlayHint, InlayHintOptions, InlayHintParams, InlayHintServerCapabilities,
     OneOf, ServerCapabilities,
 };
 use tokio_util::sync::CancellationToken;
 
-use crate::context::ServerContextSnapshot;
-
-use super::RegisterCapabilities;
-
 pub async fn on_inlay_hint_handler(
     context: ServerContextSnapshot,
     params: InlayHintParams,
     _: CancellationToken,
 ) -> Option<Vec<InlayHint>> {
     let uri = params.text_document.uri;
     let analysis = context.analysis().read().await;
-    inlay_hint(&analysis, analysis.get_file_id(&uri)?)
+    let client_id = context
+        .workspace_manager()
+        .read()
+        .await
+        .client_config
+        .client_id;
+    inlay_hint(&analysis, analysis.get_file_id(&uri)?, client_id)
 }
 
-pub fn inlay_hint(analysis: &EmmyLuaAnalysis, file_id: FileId) -> Option<Vec<InlayHint>> {
+pub fn inlay_hint(
+    analysis: &EmmyLuaAnalysis,
+    file_id: FileId,
+    client_id: ClientId,
+) -> Option<Vec<InlayHint>> {
     let semantic_model = analysis.compilation.get_semantic_model(file_id)?;
-    build_inlay_hints(&semantic_model)
+    build_inlay_hints(&semantic_model, client_id)
 }
 
 #[allow(unused_variables)]