support variadic generic template param

Author: CppCXY

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

@@ -2,11 +2,11 @@ use std::collections::HashMap;
 
 use rowan::{TextRange, TextSize};
 
-use crate::GenericTplId;
+use crate::{GenericParam, GenericTplId};
 
 #[derive(Debug, Clone)]
 pub struct FileGenericIndex {
-    generic_params: Vec<GenericParams>,
+    generic_params: Vec<TagGenericParams>,
     root_node_ids: Vec<GenericEffectId>,
     effect_nodes: Vec<GenericEffectRangeNode>,
 }
@@ -23,12 +23,12 @@ impl FileGenericIndex {
     pub fn add_generic_scope(
         &mut self,
         ranges: Vec<TextRange>,
-        params: HashMap<String, usize>,
+        params: Vec<GenericParam>,
         is_func: bool,
     ) {
         let params_id = self.generic_params.len();
         self.generic_params
-            .push(GenericParams::new(params, is_func));
+            .push(TagGenericParams::new(params, is_func));
         let params_id = GenericParamId::new(params_id);
         let root_node_ids: Vec<_> = self.root_node_ids.clone();
         for range in ranges {
@@ -93,16 +93,18 @@ impl FileGenericIndex {
         false
     }
 
-    pub fn find_generic(&self, position: TextSize, name: &str) -> Option<GenericTplId> {
+    /// Find generic parameter by position and name.
+    /// return (GenericTplId, is_variadic)
+    pub fn find_generic(&self, position: TextSize, name: &str) -> Option<(GenericTplId, bool)> {
         let params_ids = self.find_generic_params(position)?;
 
         for params_id in params_ids.iter().rev() {
             if let Some(params) = self.generic_params.get(*params_id) {
-                if let Some(id) = params.params.get(name) {
+                if let Some((id, is_variadic)) = params.params.get(name) {
                     if params.is_func {
-                        return Some(GenericTplId::Func(*id as u32));
+                        return Some((GenericTplId::Func(*id as u32), *is_variadic));
                     } else {
-                        return Some(GenericTplId::Type(*id as u32));
+                        return Some((GenericTplId::Type(*id as u32), *is_variadic));
                     }
                 }
             }
@@ -177,13 +179,17 @@ impl GenericEffectId {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GenericParams {
-    params: HashMap<String, usize>,
+pub struct TagGenericParams {
+    params: HashMap<String, (usize, bool)>, // bool: is_variadic
     is_func: bool,
 }
 
-impl GenericParams {
-    pub fn new(params: HashMap<String, usize>, is_func: bool) -> Self {
+impl TagGenericParams {
+    pub fn new(generic_params: Vec<GenericParam>, is_func: bool) -> Self {
+        let mut params = HashMap::new();
+        for (i, param) in generic_params.into_iter().enumerate() {
+            params.insert(param.name.to_string(), (i, param.is_variadic));
+        }
         Self { params, is_func }
     }
 }

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

@@ -142,10 +142,12 @@ fn infer_buildin_or_ref_type(
             LuaType::Table
         }
         _ => {
-            if let Some(tpl_id) = analyzer.generic_index.find_generic(position, name) {
+            if let Some((tpl_id, is_variadic)) = analyzer.generic_index.find_generic(position, name)
+            {
                 return LuaType::TplRef(Arc::new(GenericTpl::new(
                     tpl_id,
                     SmolStr::new(name).into(),
+                    is_variadic,
                 )));
             }
 

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

@@ -1,16 +1,16 @@
-use std::collections::HashMap;
-
 use emmylua_parser::{
     LuaAssignStat, LuaAst, LuaAstNode, LuaAstToken, LuaCommentOwner, LuaDocDescription,
     LuaDocDescriptionOwner, LuaDocGenericDeclList, LuaDocTagAlias, LuaDocTagClass, LuaDocTagEnum,
     LuaDocTagGeneric, LuaFuncStat, LuaLocalName, LuaLocalStat, LuaNameExpr, LuaSyntaxId,
     LuaSyntaxKind, LuaTokenKind, LuaVarExpr,
 };
 use rowan::TextRange;
+use smol_str::SmolStr;
 
 use super::{
     DocAnalyzer, infer_type::infer_type, preprocess_description, tags::find_owner_closure,
 };
+use crate::GenericParam;
 use crate::compilation::analyzer::doc::tags::report_orphan_tag;
 use crate::{
     LuaTypeCache, LuaTypeDeclId,
@@ -30,20 +30,14 @@ pub fn analyze_class(analyzer: &mut DocAnalyzer, tag: LuaDocTagClass) -> Option<
     let class_decl_id = class_decl.get_id();
     analyzer.current_type_id = Some(class_decl_id.clone());
     if let Some(generic_params) = tag.get_generic_decl() {
-        let params = get_generic_params(analyzer, generic_params);
-        let mut params_index = HashMap::new();
-        let mut count = 0;
-        for (name, _) in params.iter() {
-            params_index.insert(name.clone(), count);
-            count += 1;
-        }
+        let generic_params = get_generic_params(analyzer, generic_params);
 
         analyzer
             .db
             .get_type_index_mut()
-            .add_generic_params(class_decl_id.clone(), params);
+            .add_generic_params(class_decl_id.clone(), generic_params.clone());
 
-        add_generic_index(analyzer, params_index);
+        add_generic_index(analyzer, generic_params);
     }
 
     if let Some(supers) = tag.get_supers() {
@@ -154,22 +148,16 @@ pub fn analyze_alias(analyzer: &mut DocAnalyzer, tag: LuaDocTagAlias) -> Option<
     };
 
     if let Some(generic_params) = tag.get_generic_decl_list() {
-        let params = get_generic_params(analyzer, generic_params);
-        let mut params_index = HashMap::new();
-        let mut count = 0;
-        for (name, _) in params.iter() {
-            params_index.insert(name.clone(), count);
-            count += 1;
-        }
+        let generic_params = get_generic_params(analyzer, generic_params);
 
         analyzer
             .db
             .get_type_index_mut()
-            .add_generic_params(alias_decl_id.clone(), params);
+            .add_generic_params(alias_decl_id.clone(), generic_params.clone());
         let range = analyzer.comment.get_range();
         analyzer
             .generic_index
-            .add_generic_scope(vec![range], params_index, false);
+            .add_generic_scope(vec![range], generic_params, false);
     }
 
     let origin_type = infer_type(analyzer, tag.get_type()?);
@@ -189,11 +177,11 @@ pub fn analyze_alias(analyzer: &mut DocAnalyzer, tag: LuaDocTagAlias) -> Option<
 fn get_generic_params(
     analyzer: &mut DocAnalyzer,
     params: LuaDocGenericDeclList,
-) -> Vec<(String, Option<LuaType>)> {
+) -> Vec<GenericParam> {
     let mut params_result = Vec::new();
     for param in params.get_generic_decl() {
         let name = if let Some(param) = param.get_name_token() {
-            param.get_name_text().to_string()
+            SmolStr::new(param.get_name_text())
         } else {
             continue;
         };
@@ -204,13 +192,14 @@ fn get_generic_params(
             None
         };
 
-        params_result.push((name, type_ref));
+        let is_variadic = param.is_variadic();
+        params_result.push(GenericParam::new(name, type_ref, is_variadic));
     }
 
     params_result
 }
 
-fn add_generic_index(analyzer: &mut DocAnalyzer, params_index: HashMap<String, usize>) {
+fn add_generic_index(analyzer: &mut DocAnalyzer, generic_params: Vec<GenericParam>) {
     let mut ranges = Vec::new();
     let range = analyzer.comment.get_range();
     ranges.push(range);
@@ -234,7 +223,7 @@ fn add_generic_index(analyzer: &mut DocAnalyzer, params_index: HashMap<String, u
 
     analyzer
         .generic_index
-        .add_generic_scope(ranges, params_index, false);
+        .add_generic_scope(ranges, generic_params, false);
 }
 
 fn get_local_stat_reference_ranges(
@@ -328,10 +317,9 @@ pub fn analyze_func_generic(analyzer: &mut DocAnalyzer, tag: LuaDocTagGeneric) -
         report_orphan_tag(analyzer, &tag);
         return None;
     };
-    let mut params_result = HashMap::new();
+    let mut params_result = vec![];
     let mut param_info = Vec::new();
     if let Some(params_list) = tag.get_generic_decl_list() {
-        let mut count = 0;
         for param in params_list.get_generic_decl() {
             let name = if let Some(param) = param.get_name_token() {
                 param.get_name_text().to_string()
@@ -345,9 +333,12 @@ pub fn analyze_func_generic(analyzer: &mut DocAnalyzer, tag: LuaDocTagGeneric) -
                 None
             };
 
-            params_result.insert(name.clone(), count);
+            params_result.push(GenericParam::new(
+                SmolStr::new(name.as_str()),
+                type_ref.clone(),
+                false,
+            ));
             param_info.push((name, type_ref));
-            count += 1;
         }
     }
 

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

@@ -0,0 +1,20 @@
+use smol_str::SmolStr;
+
+use crate::LuaType;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct GenericParam {
+    pub name: SmolStr,
+    pub type_constraint: Option<LuaType>,
+    pub is_variadic: bool,
+}
+
+impl GenericParam {
+    pub fn new(name: SmolStr, type_constraint: Option<LuaType>, is_variadic: bool) -> Self {
+        Self {
+            name,
+            type_constraint,
+            is_variadic,
+        }
+    }
+}

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

@@ -6,7 +6,7 @@ use crate::{
     AsyncState, DbIndex, GenericTpl, LuaAliasCallType, LuaFunctionType, LuaGenericType,
     LuaInstanceType, LuaIntersectionType, LuaMemberKey, LuaMemberOwner, LuaObjectType,
     LuaSignatureId, LuaStringTplType, LuaTupleType, LuaType, LuaTypeDeclId, LuaUnionType,
-    VariadicType,
+    TypeSubstitutor, VariadicType,
 };
 
 use super::{LuaAliasCallKind, LuaMultiLineUnion};
@@ -125,7 +125,13 @@ fn humanize_def_type(db: &DbIndex, id: &LuaTypeDeclId, level: RenderLevel) -> St
 
     let generic_names = generic
         .iter()
-        .map(|it| it.0.clone())
+        .map(|it| {
+            if it.is_variadic {
+                format!("{}...", it.name)
+            } else {
+                it.name.to_string()
+            }
+        })
         .collect::<Vec<_>>()
         .join(", ");
     format!("{}<{}>", full_name, generic_names)
@@ -488,14 +494,28 @@ fn humanize_generic_type(db: &DbIndex, generic: &LuaGenericType, level: RenderLe
 
     let full_name = type_decl.get_full_name();
 
-    let generic_params = generic
+    let generic_inst_params = generic
         .get_params()
         .iter()
         .map(|ty| humanize_type(db, ty, level.next_level()))
         .collect::<Vec<_>>()
         .join(",");
 
-    format!("{}<{}>", full_name, generic_params)
+    let generic_base = format!("{}<{}>", full_name, generic_inst_params);
+    if (level == RenderLevel::Detailed || level == RenderLevel::Documentation)
+        && type_decl.is_alias()
+    {
+        let substituor = TypeSubstitutor::from_type_array(generic.get_params().clone());
+        if let Some(origin_type) = type_decl.get_alias_origin(db, Some(&substituor)) {
+            // prevent infinite recursion
+            if origin_type.is_function() {
+                let origin_type_str = humanize_type(db, &origin_type, level);
+                return format!("{} = {}", generic_base, origin_type_str);
+            }
+        }
+    }
+
+    generic_base
 }
 
 fn humanize_table_const_type_detail_and_simple(

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

@@ -1,3 +1,4 @@
+mod generic_param;
 mod humanize_type;
 mod test;
 mod type_decl;
@@ -8,6 +9,7 @@ mod types;
 
 use super::traits::LuaIndex;
 use crate::{DbIndex, FileId, InFiled};
+pub use generic_param::GenericParam;
 pub use humanize_type::{RenderLevel, format_union_type, humanize_type};
 use std::collections::{HashMap, HashSet};
 pub use type_decl::{
@@ -24,7 +26,7 @@ pub struct LuaTypeIndex {
     file_using_namespace: HashMap<FileId, Vec<String>>,
     file_types: HashMap<FileId, Vec<LuaTypeDeclId>>,
     full_name_type_map: HashMap<LuaTypeDeclId, LuaTypeDecl>,
-    generic_params: HashMap<LuaTypeDeclId, Vec<(String, Option<LuaType>)>>,
+    generic_params: HashMap<LuaTypeDeclId, Vec<GenericParam>>,
     supers: HashMap<LuaTypeDeclId, Vec<InFiled<LuaType>>>,
     types: HashMap<LuaTypeOwner, LuaTypeCache>,
     in_filed_type_owner: HashMap<FileId, HashSet<LuaTypeOwner>>,
@@ -161,18 +163,11 @@ impl LuaTypeIndex {
         result
     }
 
-    pub fn add_generic_params(
-        &mut self,
-        decl_id: LuaTypeDeclId,
-        params: Vec<(String, Option<LuaType>)>,
-    ) {
+    pub fn add_generic_params(&mut self, decl_id: LuaTypeDeclId, params: Vec<GenericParam>) {
         self.generic_params.insert(decl_id, params);
     }
 
-    pub fn get_generic_params(
-        &self,
-        decl_id: &LuaTypeDeclId,
-    ) -> Option<&Vec<(String, Option<LuaType>)>> {
+    pub fn get_generic_params(&self, decl_id: &LuaTypeDeclId) -> Option<&Vec<GenericParam>> {
         self.generic_params.get(decl_id)
     }
 

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

@@ -1291,17 +1291,29 @@ impl GenericTplId {
     pub fn is_type(&self) -> bool {
         matches!(self, GenericTplId::Type(_))
     }
+
+    pub fn with_idx(&self, idx: u32) -> Self {
+        match self {
+            GenericTplId::Type(_) => GenericTplId::Type(idx),
+            GenericTplId::Func(_) => GenericTplId::Func(idx),
+        }
+    }
 }
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct GenericTpl {
     tpl_id: GenericTplId,
     name: ArcIntern<SmolStr>,
+    is_variadic: bool,
 }
 
 impl GenericTpl {
-    pub fn new(tpl_id: GenericTplId, name: ArcIntern<SmolStr>) -> Self {
-        Self { tpl_id, name }
+    pub fn new(tpl_id: GenericTplId, name: ArcIntern<SmolStr>, is_variadic: bool) -> Self {
+        Self {
+            tpl_id,
+            name,
+            is_variadic,
+        }
     }
 
     pub fn get_tpl_id(&self) -> GenericTplId {
@@ -1311,6 +1323,10 @@ impl GenericTpl {
     pub fn get_name(&self) -> &str {
         &self.name
     }
+
+    pub fn is_variadic(&self) -> bool {
+        self.is_variadic
+    }
 }
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]