Add option to increase verbosity of types rendered in hovers

Fix EmmyLua/VSCode-EmmyLua#250

Author: taminomara

crates/emmylua_code_analysis/src/config/configs/hover.rs

@@ -8,12 +8,21 @@ pub struct EmmyrcHover {
     #[serde(default = "default_true")]
     #[schemars(extend("x-vscode-setting" = true))]
     pub enable: bool,
+
+    /// Increase verbosity of types shown in hovers.
+    ///
+    /// Enabling this option will increase maximum nesting of displayed types,
+    /// add alias expansions on top level, increase number of shown members.
+    #[serde(default)]
+    #[schemars(extend("x-vscode-setting" = true))]
+    pub verbose: bool,
 }
 
 impl Default for EmmyrcHover {
     fn default() -> Self {
         Self {
             enable: default_true(),
+            verbose: false,
         }
     }
 }

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

@@ -1,6 +1,5 @@
-use std::collections::HashSet;
-
 use itertools::Itertools;
+use std::collections::HashSet;
 
 use crate::{
     DbIndex, GenericTpl, LuaAliasCallType, LuaFunctionType, LuaGenericType, LuaInstanceType,
@@ -13,6 +12,7 @@ use super::{LuaAliasCallKind, LuaMultiLineUnion};
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum RenderLevel {
     Documentation,
+    Verbose,
     Detailed,
     Simple,
     Normal,
@@ -24,6 +24,7 @@ impl RenderLevel {
     pub fn next_level(self) -> RenderLevel {
         match self {
             RenderLevel::Documentation => RenderLevel::Simple,
+            RenderLevel::Verbose => RenderLevel::Detailed,
             RenderLevel::Detailed => RenderLevel::Simple,
             RenderLevel::Simple => RenderLevel::Normal,
             RenderLevel::Normal => RenderLevel::Brief,
@@ -74,7 +75,7 @@ pub fn humanize_type(db: &DbIndex, ty: &LuaType, level: RenderLevel) -> String {
         LuaType::Ref(id) => {
             if let Some(type_decl) = db.get_type_index().get_type_decl(id) {
                 let name = type_decl.get_full_name().to_string();
-                humanize_simple_type(db, id, &name, level).unwrap_or(name)
+                humanize_simple_type(db, id, &name, level)
             } else {
                 id.get_name().to_string()
             }
@@ -114,10 +115,7 @@ fn humanize_def_type(db: &DbIndex, id: &LuaTypeDeclId, level: RenderLevel) -> St
     let full_name = type_decl.get_full_name();
     let generic = match db.get_type_index().get_generic_params(id) {
         Some(generic) => generic,
-        None => {
-            return humanize_simple_type(db, id, &full_name, level)
-                .unwrap_or(full_name.to_string());
-        }
+        None => return humanize_simple_type(db, id, &full_name, level),
     };
 
     let generic_names = generic
@@ -133,15 +131,20 @@ fn humanize_simple_type(
     id: &LuaTypeDeclId,
     name: &str,
     level: RenderLevel,
-) -> Option<String> {
-    if !matches!(level, RenderLevel::Detailed | RenderLevel::Documentation) {
-        return Some(name.to_string());
+) -> String {
+    if !matches!(
+        level,
+        RenderLevel::Detailed | RenderLevel::Verbose | RenderLevel::Documentation
+    ) {
+        return name.to_string();
     }
     let max_display_count = 12;
 
     let member_owner = LuaMemberOwner::Type(id.clone());
     let member_index = db.get_member_index();
-    let members = member_index.get_sorted_members(&member_owner)?;
+    let members = member_index
+        .get_sorted_members(&member_owner)
+        .unwrap_or_default();
     let mut member_vec = Vec::new();
     let mut function_vec = Vec::new();
     for member in members {
@@ -159,7 +162,23 @@ fn humanize_simple_type(
     }
 
     if member_vec.is_empty() && function_vec.is_empty() {
-        return Some(name.to_string());
+        if matches!(level, RenderLevel::Detailed | RenderLevel::Verbose) {
+            'expand: {
+                let Some(type_decl) = db.get_type_index().get_type_decl(id) else {
+                    break 'expand;
+                };
+                let Some(origin) = type_decl.get_alias_ref() else {
+                    break 'expand;
+                };
+                return format!(
+                    "{} {}",
+                    name,
+                    humanize_type(db, &origin, level.next_level())
+                );
+            }
+        }
+
+        return name.to_string();
     }
     let all_count = member_vec.len() + function_vec.len();
 
@@ -171,7 +190,8 @@ fn humanize_simple_type(
             typ,
             humanize_type(db, typ, level.next_level()),
             level,
-        );
+        )
+        .replace("\n", "\n    ");
 
         member_strings.push_str(&format!("    {},\n", member_string));
         count += 1;
@@ -186,7 +206,8 @@ fn humanize_simple_type(
                 &LuaType::Function,
                 "function".to_string(),
                 level,
-            );
+            )
+            .replace("\n", "\n    ");
 
             member_strings.push_str(&format!("    {},\n", member_string));
             count += 1;
@@ -198,7 +219,7 @@ fn humanize_simple_type(
     if count >= max_display_count {
         member_strings.push_str(&format!("    ...(+{})\n", all_count - max_display_count));
     }
-    Some(format!("{} {{\n{}}}", name, member_strings))
+    format!("{} {{\n{}}}", name, member_strings)
 }
 
 fn humanize_union_type(db: &DbIndex, union: &LuaUnionType, level: RenderLevel) -> String {
@@ -218,6 +239,7 @@ where
     let types = union.into_vec();
     let num = match level {
         RenderLevel::Documentation => 500,
+        RenderLevel::Verbose => 10,
         RenderLevel::Detailed => 8,
         RenderLevel::Simple => 6,
         RenderLevel::Normal => 4,
@@ -264,6 +286,7 @@ fn humanize_multi_line_union_type(
     let members = multi_union.get_unions();
     let num = match level {
         RenderLevel::Documentation => 500,
+        RenderLevel::Verbose => 15,
         RenderLevel::Detailed => 10,
         RenderLevel::Simple => 8,
         RenderLevel::Normal => 4,
@@ -304,6 +327,7 @@ fn humanize_tuple_type(db: &DbIndex, tuple: &LuaTupleType, level: RenderLevel) -
     let types = tuple.get_types();
     let num = match level {
         RenderLevel::Documentation => 500,
+        RenderLevel::Verbose => 15,
         RenderLevel::Detailed => 10,
         RenderLevel::Simple => 8,
         RenderLevel::Normal => 4,
@@ -398,6 +422,7 @@ fn humanize_doc_function_type(
 fn humanize_object_type(db: &DbIndex, object: &LuaObjectType, level: RenderLevel) -> String {
     let num = match level {
         RenderLevel::Documentation => 500,
+        RenderLevel::Verbose => 15,
         RenderLevel::Detailed => 10,
         RenderLevel::Simple => 8,
         RenderLevel::Normal => 4,
@@ -457,6 +482,7 @@ fn humanize_intersect_type(
 ) -> String {
     let num = match level {
         RenderLevel::Documentation => 500,
+        RenderLevel::Verbose => 15,
         RenderLevel::Detailed => 10,
         RenderLevel::Simple => 8,
         RenderLevel::Normal => 4,
@@ -518,7 +544,8 @@ fn humanize_table_const_type_detail_and_simple(
             &type_cache.as_type(),
             humanize_type(db, &type_cache.as_type(), level.next_level()),
             level,
-        );
+        )
+        .replace("\n", "\n    ");
 
         match level {
             RenderLevel::Detailed => {
@@ -575,6 +602,7 @@ fn humanize_table_generic_type(
 ) -> String {
     let num = match level {
         RenderLevel::Documentation => 500,
+        RenderLevel::Verbose => 15,
         RenderLevel::Detailed => 10,
         RenderLevel::Simple => 8,
         RenderLevel::Normal => 4,
@@ -622,6 +650,7 @@ fn humanize_variadic_type(db: &DbIndex, multi: &VariadicType, level: RenderLevel
         VariadicType::Multi(types) => {
             let max_num = match level {
                 RenderLevel::Documentation => 500,
+                RenderLevel::Verbose => 15,
                 RenderLevel::Detailed => 10,
                 RenderLevel::Simple => 8,
                 RenderLevel::Normal => 4,

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

@@ -30,9 +30,10 @@ pub fn build_semantic_info_hover(
     semantic_info: SemanticInfo,
     range: TextRange,
 ) -> Option<Hover> {
+    let verbose = semantic_model.get_emmyrc().hover.verbose;
     let typ = semantic_info.clone().typ;
     if semantic_info.semantic_decl.is_none() {
-        return build_hover_without_property(db, document, token, typ);
+        return build_hover_without_property(db, document, token, typ, verbose);
     }
     let hover_builder = build_hover_content(
         compilation,
@@ -42,6 +43,7 @@ pub fn build_semantic_info_hover(
         semantic_info.semantic_decl.unwrap(),
         false,
         Some(token.clone()),
+        verbose,
     );
     if let Some(hover_builder) = hover_builder {
         hover_builder.build_hover_result(document.to_lsp_range(range))
@@ -55,8 +57,15 @@ fn build_hover_without_property(
     document: &LuaDocument,
     token: LuaSyntaxToken,
     typ: LuaType,
+    verbose: bool,
 ) -> Option<Hover> {
-    let hover = humanize_type(db, &typ, RenderLevel::Detailed);
+    let render_level = if verbose {
+        RenderLevel::Verbose
+    } else {
+        RenderLevel::Detailed
+    };
+
+    let hover = humanize_type(db, &typ, render_level);
     Some(Hover {
         contents: HoverContents::Markup(MarkupContent {
             kind: lsp_types::MarkupKind::Markdown,
@@ -89,6 +98,7 @@ pub fn build_hover_content_for_completion<'a>(
         property_id,
         true,
         None,
+        semantic_model.get_emmyrc().hover.verbose,
     )
 }
 
@@ -100,19 +110,20 @@ fn build_hover_content<'a>(
     property_id: LuaSemanticDeclId,
     is_completion: bool,
     token: Option<LuaSyntaxToken>,
+    verbose: bool,
 ) -> Option<HoverBuilder<'a>> {
     let mut builder = HoverBuilder::new(compilation, semantic_model, token, is_completion);
     match property_id {
         LuaSemanticDeclId::LuaDecl(decl_id) => {
             let typ = typ?;
-            build_decl_hover(&mut builder, db, typ, decl_id);
+            build_decl_hover(&mut builder, db, typ, decl_id, verbose);
         }
         LuaSemanticDeclId::Member(member_id) => {
             let typ = typ?;
-            build_member_hover(&mut builder, db, typ, member_id);
+            build_member_hover(&mut builder, db, typ, member_id, verbose);
         }
         LuaSemanticDeclId::TypeDecl(type_decl_id) => {
-            build_type_decl_hover(&mut builder, db, type_decl_id);
+            build_type_decl_hover(&mut builder, db, type_decl_id, verbose);
         }
         _ => return None,
     }
@@ -124,6 +135,7 @@ fn build_decl_hover(
     db: &DbIndex,
     typ: LuaType,
     decl_id: LuaDeclId,
+    verbose: bool,
 ) -> Option<()> {
     let decl = db.get_decl_index().get_decl(&decl_id)?;
 
@@ -151,7 +163,7 @@ fn build_decl_hover(
             semantic_decls.push((semantic_decl, typ.clone()));
         }
 
-        hover_function_type(builder, db, &semantic_decls);
+        hover_function_type(builder, db, &semantic_decls, verbose);
 
         if let Some((LuaSemanticDeclId::Member(member_id), _)) = semantic_decls
             .iter()
@@ -166,7 +178,7 @@ fn build_decl_hover(
             .add_signature_params_rets_description(builder.semantic_model.get_type(decl_id.into()));
     } else {
         if typ.is_const() {
-            let const_value = hover_const_type(db, &typ);
+            let const_value = hover_const_type(db, &typ, verbose);
             let prefix = if decl.is_local() {
                 "local "
             } else {
@@ -177,7 +189,7 @@ fn build_decl_hover(
             let decl_hover_type =
                 get_hover_type(builder, builder.semantic_model).unwrap_or(typ.clone());
             let type_humanize_text =
-                hover_humanize_type(builder, &decl_hover_type, Some(RenderLevel::Detailed));
+                hover_humanize_type(builder, &decl_hover_type, verbose, RenderLevel::Detailed);
             let prefix = if decl.is_local() {
                 "local "
             } else {
@@ -209,6 +221,7 @@ fn build_member_hover(
     db: &DbIndex,
     typ: LuaType,
     member_id: LuaMemberId,
+    verbose: bool,
 ) -> Option<()> {
     let member = db.get_member_index().get_member(&member_id)?;
     let mut semantic_decls = find_member_origin_owners(
@@ -245,7 +258,7 @@ fn build_member_hover(
             semantic_decls.push((semantic_decl, typ.clone()));
         }
 
-        hover_function_type(builder, db, &semantic_decls);
+        hover_function_type(builder, db, &semantic_decls, verbose);
 
         builder.set_location_path(Some(&member));
 
@@ -255,14 +268,14 @@ fn build_member_hover(
         );
     } else {
         if typ.is_const() {
-            let const_value = hover_const_type(db, &typ);
+            let const_value = hover_const_type(db, &typ, verbose);
             builder.set_type_description(format!("(field) {}: {}", member_name, const_value));
             builder.set_location_path(Some(&member));
         } else {
             let member_hover_type =
                 get_hover_type(builder, builder.semantic_model).unwrap_or(typ.clone());
             let type_humanize_text =
-                hover_humanize_type(builder, &member_hover_type, Some(RenderLevel::Simple));
+                hover_humanize_type(builder, &member_hover_type, verbose, RenderLevel::Simple);
             builder
                 .set_type_description(format!("(field) {}: {}", member_name, type_humanize_text));
             builder.set_location_path(Some(&member));
@@ -285,23 +298,27 @@ fn build_type_decl_hover(
     builder: &mut HoverBuilder,
     db: &DbIndex,
     type_decl_id: LuaTypeDeclId,
+    verbose: bool,
 ) -> Option<()> {
+    let render_level = if verbose {
+        RenderLevel::Verbose
+    } else {
+        RenderLevel::Detailed
+    };
+
     let type_decl = db.get_type_index().get_type_decl(&type_decl_id)?;
     let type_description = if type_decl.is_alias() {
         if let Some(origin) = type_decl.get_alias_origin(db, None) {
-            let origin_type = humanize_type(db, &origin, RenderLevel::Detailed);
+            let origin_type = humanize_type(db, &origin, render_level);
             format!("(alias) {} = {}", type_decl.get_name(), origin_type)
         } else {
             "".to_string()
         }
     } else if type_decl.is_enum() {
-        format!("(enum) {}", type_decl.get_name())
+        let humanize_text = humanize_type(db, &LuaType::Ref(type_decl_id.clone()), render_level);
+        format!("(enum) {}", humanize_text)
     } else {
-        let humanize_text = humanize_type(
-            db,
-            &LuaType::Def(type_decl_id.clone()),
-            RenderLevel::Detailed,
-        );
+        let humanize_text = humanize_type(db, &LuaType::Ref(type_decl_id.clone()), render_level);
         format!("(class) {}", humanize_text)
     };