refactor union

Author: CppCXY

CHANGELOG.md

@@ -19,6 +19,8 @@
 
 `FIX` Fix select function and add std.Select type 
 
+`CHG` Refactor Union type
+
 # 0.5.1 
 
 `FIX` Fix issue `emmylua_ls` might not exit in unix.

Cargo.lock

@@ -8,7 +8,7 @@ members = [
 [workspace.dependencies]
 # local
 emmylua_code_analysis = { path = "crates/emmylua_code_analysis", version = "0.5.0" }
-emmylua_parser = { path = "crates/emmylua_parser", version = "0.9.6" }
+emmylua_parser = { path = "crates/emmylua_parser", version = "0.10.0" }
 emmylua_diagnostic_macro = { path = "crates/emmylua_diagnostic_macro", version = "0.4.0" }
 
 # external

Cargo.toml

@@ -1,9 +1,10 @@
 use std::sync::Arc;
 
 use emmylua_parser::{
-    LuaAst, LuaAstNode, LuaDocBinaryType, LuaDocFuncType, LuaDocGenericType, LuaDocObjectFieldKey,
-    LuaDocObjectType, LuaDocStrTplType, LuaDocType, LuaDocUnaryType, LuaDocVariadicType,
-    LuaLiteralToken, LuaSyntaxKind, LuaTypeBinaryOperator, LuaTypeUnaryOperator, LuaVarExpr,
+    LuaAst, LuaAstNode, LuaDocBinaryType, LuaDocDetailOwner, LuaDocFuncType, LuaDocGenericType,
+    LuaDocMultiLineUnionType, LuaDocObjectFieldKey, LuaDocObjectType, LuaDocStrTplType, LuaDocType,
+    LuaDocUnaryType, LuaDocVariadicType, LuaLiteralToken, LuaSyntaxKind, LuaTypeBinaryOperator,
+    LuaTypeUnaryOperator, LuaVarExpr,
 };
 use rowan::TextRange;
 use smol_str::SmolStr;
@@ -13,10 +14,10 @@ use crate::{
         AnalyzeError, LuaAliasCallType, LuaFunctionType, LuaGenericType, LuaIndexAccessKey,
         LuaIntersectionType, LuaObjectType, LuaStringTplType, LuaTupleType, LuaType, LuaUnionType,
     },
-    DiagnosticCode, GenericTpl, LuaAliasCallKind, TypeOps,
+    DiagnosticCode, GenericTpl, LuaAliasCallKind, LuaMultiLineUnion, TypeOps,
 };
 
-use super::DocAnalyzer;
+use super::{preprocess_description, DocAnalyzer};
 
 pub fn infer_type(analyzer: &mut DocAnalyzer, node: LuaDocType) -> LuaType {
     match node {
@@ -103,6 +104,9 @@ pub fn infer_type(analyzer: &mut DocAnalyzer, node: LuaDocType) -> LuaType {
         LuaDocType::Variadic(variadic_type) => {
             return infer_variadic_type(analyzer, variadic_type).unwrap_or(LuaType::Unknown);
         }
+        LuaDocType::MultiLineUnion(multi_union) => {
+            return infer_multi_line_union_type(analyzer, multi_union);
+        }
         _ => {} // LuaDocType::Conditional(lua_doc_conditional_type) => todo!(),
     }
     LuaType::Unknown
@@ -482,3 +486,35 @@ fn infer_variadic_type(
 
     Some(LuaType::Variadic(base.into()))
 }
+
+fn infer_multi_line_union_type(
+    analyzer: &mut DocAnalyzer,
+    multi_union: LuaDocMultiLineUnionType,
+) -> LuaType {
+    let mut union_members = Vec::new();
+    for field in multi_union.get_fields() {
+        let alias_member_type = if let Some(field_type) = field.get_type() {
+            let type_ref = infer_type(analyzer, field_type);
+            if type_ref.is_unknown() {
+                continue;
+            }
+            type_ref
+        } else {
+            continue;
+        };
+
+        let description = if let Some(description_text) = field.get_detail_text() {
+            if !description_text.is_empty() {
+                Some(preprocess_description(&description_text))
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        union_members.push((alias_member_type, description));
+    }
+
+    LuaType::MultiLineUnion(LuaMultiLineUnion::new(union_members).into())
+}

crates/emmylua_code_analysis/src/compilation/analyzer/doc/infer_type.rs

@@ -119,5 +119,7 @@ pub fn preprocess_description(mut description: &str) -> String {
         }
         result.push('\n');
     }
-    result
+
+    // trim end
+    result.trim_end().to_string()
 }

crates/emmylua_code_analysis/src/compilation/analyzer/doc/mod.rs

@@ -2,15 +2,14 @@ use std::collections::HashMap;
 
 use emmylua_parser::{
     LuaAssignStat, LuaAst, LuaAstNode, LuaAstToken, LuaCommentOwner, LuaDocDescriptionOwner,
-    LuaDocDetailOwner, LuaDocGenericDeclList, LuaDocTagAlias, LuaDocTagClass, LuaDocTagEnum,
-    LuaDocTagGeneric, LuaFuncStat, LuaLocalName, LuaLocalStat, LuaNameExpr, LuaSyntaxId,
-    LuaSyntaxKind, LuaTokenKind, LuaVarExpr,
+    LuaDocGenericDeclList, LuaDocTagAlias, LuaDocTagClass, LuaDocTagEnum, LuaDocTagGeneric,
+    LuaFuncStat, LuaLocalName, LuaLocalStat, LuaNameExpr, LuaSyntaxId, LuaSyntaxKind, LuaTokenKind,
+    LuaVarExpr,
 };
 use rowan::TextRange;
 
 use crate::db_index::{
-    LuaDeclId, LuaDeclTypeKind, LuaMember, LuaMemberId, LuaMemberKey, LuaMemberOwner,
-    LuaPropertyOwnerId, LuaSignatureId, LuaType,
+    LuaDeclId, LuaDeclTypeKind, LuaMemberId, LuaPropertyOwnerId, LuaSignatureId, LuaType,
 };
 
 use super::{
@@ -159,57 +158,14 @@ pub fn analyze_alias(analyzer: &mut DocAnalyzer, tag: LuaDocTagAlias) -> Option<
             .add_generic_scope(vec![range], params_index, false);
     }
 
-    if let Some(origin_type) = tag.get_type() {
-        let replace_type = infer_type(analyzer, origin_type);
-        if replace_type.is_unknown() {
-            return None;
-        }
-        let alias = analyzer
-            .db
-            .get_type_index_mut()
-            .get_type_decl_mut(&alias_decl_id)?;
-        alias.add_alias_origin(replace_type);
-    } else if let Some(field_list) = tag.get_alias_fields() {
-        let mut union_members = Vec::new();
-        for (i, field) in field_list.get_fields().enumerate() {
-            let alias_member_type = if let Some(field_type) = field.get_type() {
-                let type_ref = infer_type(analyzer, field_type);
-                if type_ref.is_unknown() {
-                    continue;
-                }
-                type_ref
-            } else {
-                continue;
-            };
+    let origin_type = infer_type(analyzer, tag.get_type()?);
 
-            let member = LuaMember::new(
-                LuaMemberOwner::Type(alias_decl_id.clone()),
-                LuaMemberKey::Integer(i as i64),
-                file_id,
-                field.get_syntax_id(),
-                Some(alias_member_type),
-            );
-            let member_id = analyzer.db.get_member_index_mut().add_member(member);
-            union_members.push(member_id);
-            if let Some(description_text) = field.get_detail_text() {
-                if description_text.is_empty() {
-                    continue;
-                }
-                let description_text = preprocess_description(&description_text);
-                analyzer.db.get_property_index_mut().add_description(
-                    file_id,
-                    LuaPropertyOwnerId::Member(member_id),
-                    description_text,
-                );
-            }
-        }
+    let alias = analyzer
+        .db
+        .get_type_index_mut()
+        .get_type_decl_mut(&alias_decl_id)?;
 
-        let alias = analyzer
-            .db
-            .get_type_index_mut()
-            .get_type_decl_mut(&alias_decl_id)?;
-        alias.add_alias_union_members(union_members);
-    }
+    alias.add_alias_origin(origin_type);
 
     let description_text = tag.get_description()?.get_description_text();
     if description_text.is_empty() {

crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_def_tags.rs

@@ -5,6 +5,8 @@ use crate::{
     LuaUnionType, TypeSubstitutor,
 };
 
+use super::LuaMultiLineUnion;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum RenderLevel {
     Detailed,
@@ -83,6 +85,9 @@ pub fn humanize_type(db: &DbIndex, ty: &LuaType, level: RenderLevel) -> String {
         LuaType::Signature(signature_id) => humanize_signature_type(db, signature_id, level),
         LuaType::Namespace(ns) => format!("{{ {} }}", ns),
         LuaType::Variadic(inner) => format!("{}...", humanize_type(db, inner, level.next_level())),
+        LuaType::MultiLineUnion(multi_union) => {
+            humanize_multi_line_union_type(db, multi_union, level)
+        }
         _ => "unknown".to_string(),
     }
 }
@@ -97,8 +102,7 @@ fn humanize_def_type(db: &DbIndex, id: &LuaTypeDeclId, level: RenderLevel) -> St
     let full_name = type_decl.get_full_name();
     let generic = db.get_type_index().get_generic_params(id);
     if generic.is_none() {
-        return humanize_simple_type(db, id, &full_name, level)
-            .unwrap_or(full_name.to_string());
+        return humanize_simple_type(db, id, &full_name, level).unwrap_or(full_name.to_string());
     }
 
     let generic_names = generic
@@ -181,6 +185,51 @@ fn humanize_union_type(db: &DbIndex, union: &LuaUnionType, level: RenderLevel) -
     format!("({}{})", type_str, dots)
 }
 
+fn humanize_multi_line_union_type(
+    db: &DbIndex,
+    multi_union: &LuaMultiLineUnion,
+    level: RenderLevel,
+) -> String {
+    let members = multi_union.get_unions();
+    let num = match level {
+        RenderLevel::Detailed => 10,
+        RenderLevel::Simple => 8,
+        RenderLevel::Normal => 4,
+        RenderLevel::Brief => 2,
+        RenderLevel::Minimal => {
+            return "union<...>".to_string();
+        }
+    };
+    let dots = if members.len() > num { "..." } else { "" };
+
+    let type_str = members
+        .iter()
+        .take(num)
+        .map(|(ty, _)| humanize_type(db, ty, level.next_level()))
+        .collect::<Vec<_>>()
+        .join("|");
+
+    let mut text = format!("({}{})", type_str, dots);
+    if level != RenderLevel::Detailed {
+        return text;
+    }
+
+    text.push_str("\n");
+    for (typ, description) in members {
+        let type_humanize_text = humanize_type(db, &typ, RenderLevel::Minimal);
+        if let Some(description) = description {
+            text.push_str(&format!(
+                "    | {}  --{}\n",
+                type_humanize_text, description
+            ));
+        } else {
+            text.push_str(&format!("    | {}\n", type_humanize_text));
+        }
+    }
+
+    text
+}
+
 fn humanize_tuple_type(db: &DbIndex, tuple: &LuaTupleType, level: RenderLevel) -> String {
     let types = tuple.get_types();
     let num = match level {
@@ -371,7 +420,7 @@ fn humanize_generic_type(db: &DbIndex, generic: &LuaGenericType, level: RenderLe
     let simple_name = type_decl.get_name();
     match level {
         RenderLevel::Brief => {
-            if type_decl.is_alias_replace() {
+            if type_decl.is_alias() {
                 let params = generic
                     .get_params()
                     .iter()
@@ -627,9 +676,13 @@ fn build_table_member_string(
 ) -> String {
     let (member_value, separator) = if level == RenderLevel::Detailed {
         let val = match ty {
-            LuaType::IntegerConst(_) | LuaType::DocIntegerConst(_) => format!("integer = {member_value_string}"),
+            LuaType::IntegerConst(_) | LuaType::DocIntegerConst(_) => {
+                format!("integer = {member_value_string}")
+            }
             LuaType::FloatConst(_) => format!("number = {member_value_string}"),
-            LuaType::StringConst(_) | LuaType::DocStringConst(_) => format!("string = {member_value_string}"),
+            LuaType::StringConst(_) | LuaType::DocStringConst(_) => {
+                format!("string = {member_value_string}")
+            }
             LuaType::BooleanConst(_) => format!("boolean = {member_value_string}"),
             _ => member_value_string,
         };

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

@@ -98,7 +98,7 @@ impl LuaTypeIndex {
             }
 
             let location = LuaDeclLocation { file_id, range };
-            decls.defined_locations.push(location);
+            decls.locations.push(location);
         } else {
             let just_name = if let Some(i) = basic_name.rfind('.') {
                 basic_name[i + 1..].to_string()