extend const table type humanization

This patch extends the humanized variant of the const table. Previously,
every constant table has been displayed as `table`. This patch makes
short constant tables (having full type name no more than 36 symbols
length) humanize into preciser types. See the following examples.

```lua
-- a is humanized like `{ [1] = "test", [3] = 4 }`
local a = { [1] = 'test', [3] = 4 }
-- b is humanized like `{ name = "Pete", age = 36 }`
local b = { name = 'pete', age = 36 }
-- c is humanized like `{ a = table }`
local c = { a = { very_very_very_very_very_long = 10000 } }
-- d is humanized like `table`
local d = { very_very_very_very_very_long = 10000 }
```

Author: georgiy-belyanin

CHANGELOG.md

@@ -6,6 +6,8 @@
 
 `FIX` now configurations are loaded properly in NeoVim in cases when no extra LSP configuration parameters are provided
 
+`CHG` extended humanization of small constant table types
+
 # 0.3.3 
 
 `NEW` Add Develop Guide

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

@@ -1,6 +1,6 @@
 use crate::{
     DbIndex, GenericTpl, LuaExistFieldType, LuaExtendedType, LuaFunctionType, LuaGenericType,
-    LuaInstanceType, LuaIntersectionType, LuaMemberKey, LuaMultiReturn, LuaObjectType,
+    LuaInstanceType, LuaIntersectionType, LuaMemberKey, LuaMemberOwner, LuaMultiReturn, LuaObjectType,
     LuaSignatureId, LuaStringTplType, LuaTupleType, LuaType, LuaTypeDeclId, LuaUnionType,
 };
 
@@ -18,7 +18,10 @@ pub fn humanize_type(db: &DbIndex, ty: &LuaType) -> String {
         LuaType::Userdata => "userdata".to_string(),
         LuaType::IntegerConst(i) => i.to_string(),
         LuaType::FloatConst(f) => f.to_string(),
-        LuaType::TableConst(_) => "table".to_string(),
+        LuaType::TableConst(v) => {
+            let member_owner = LuaMemberOwner::Element(v.clone());
+            humanize_table_const_type(db, member_owner)
+        },
         LuaType::Global => "global".to_string(),
         LuaType::Def(id) => humanize_def_type(db, id),
         LuaType::Union(union) => humanize_union_type(db, union),
@@ -245,6 +248,43 @@ fn humanize_generic_type(db: &DbIndex, generic: &LuaGenericType) -> String {
     format!("{}<{}>", simple_name, generic_params)
 }
 
+fn humanize_table_const_type_extended(db: &DbIndex, member_owned: LuaMemberOwner) -> Option<String> {
+    let member_index = db.get_member_index();
+    let member_map = member_index.get_member_map(member_owned)?;
+
+    let members_string =  member_map.into_iter().fold(Some("".to_string()), |acc, member| {
+        let prev_member_string = acc?;
+        let (member_key, member_id) = member;
+        let member_value = member_index.get_member(member_id)?;
+        let member_value_string = humanize_type(db, member_value.get_decl_type());
+
+        let member_string = if let Some(name) = member_key.get_name() {
+            format!("{} = {}", name, member_value_string)
+        } else if let Some(i) = member_key.get_integer() {
+            format!("[{}] = {}", i, member_value_string)
+        } else {
+            format!("{}", member_value_string)
+        };
+
+        // Maximum typename length is 36 symbols.
+        if prev_member_string.len() + member_string.len() <= 32 {
+            if prev_member_string.len() > 0 {
+                Some(format!("{}, {}", prev_member_string, member_string))
+            } else {
+                Some(format!("{}", member_string))
+            }
+        } else {
+            None
+        }
+    })?;
+
+    Some(format!("{{ {} }}", members_string))
+}
+
+fn humanize_table_const_type(db: &DbIndex, member_owned: LuaMemberOwner) -> String {
+    humanize_table_const_type_extended(db, member_owned).unwrap_or("table".to_string())
+}
+
 fn humanize_table_generic_type(db: &DbIndex, table_generic_params: &Vec<LuaType>) -> String {
     let generic_params = table_generic_params
         .iter()