add variadic type

Author: CppCXY

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

@@ -2,8 +2,8 @@ use std::sync::Arc;
 
 use emmylua_parser::{
     LuaAst, LuaAstNode, LuaDocBinaryType, LuaDocFuncType, LuaDocGenericType, LuaDocObjectFieldKey,
-    LuaDocObjectType, LuaDocStrTplType, LuaDocType, LuaDocUnaryType, LuaLiteralToken,
-    LuaTypeBinaryOperator, LuaTypeUnaryOperator, LuaVarExpr,
+    LuaDocObjectType, LuaDocStrTplType, LuaDocType, LuaDocUnaryType, LuaDocVariadicType,
+    LuaLiteralToken, LuaTypeBinaryOperator, LuaTypeUnaryOperator, LuaVarExpr,
 };
 use rowan::TextRange;
 use smol_str::SmolStr;
@@ -99,8 +99,10 @@ pub fn infer_type(analyzer: &mut DocAnalyzer, node: LuaDocType) -> LuaType {
         LuaDocType::StrTpl(str_tpl) => {
             return infer_str_tpl(analyzer, str_tpl);
         }
+        LuaDocType::Variadic(variadic_type) => {
+            return infer_variadic_type(analyzer, variadic_type).unwrap_or(LuaType::Unknown);
+        }
         _ => {} // LuaDocType::Conditional(lua_doc_conditional_type) => todo!(),
-                // LuaDocType::Variadic(lua_doc_variadic_type) => todo!(),
     }
     LuaType::Unknown
 }
@@ -413,3 +415,11 @@ fn infer_str_tpl(analyzer: &mut DocAnalyzer, str_tpl: LuaDocStrTplType) -> LuaTy
     }
     LuaType::Unknown
 }
+
+fn infer_variadic_type(analyzer: &mut DocAnalyzer, variadic_type: LuaDocVariadicType) -> Option<LuaType> {
+    let name_type = variadic_type.get_name_type()?;
+    let name = name_type.get_name_text()?;
+    let base = infer_buildin_or_ref_type(analyzer, &name, name_type.get_range());
+
+    Some(LuaType::Variadic(base.into()))
+}

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

@@ -58,6 +58,7 @@ pub fn humanize_type(db: &DbIndex, ty: &LuaType) -> String {
         LuaType::Instance(ins) => humanize_instance_type(db, ins),
         LuaType::Signature(signature_id) => humanize_signature_type(db, signature_id),
         LuaType::Namespace(ns) => format!("{{ {} }}", ns),
+        LuaType::Variadic(inner) => format!("{}...", humanize_type(db, inner)),
         _ => "unknown".to_string(),
     }
 }

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

@@ -56,6 +56,7 @@ pub enum LuaType {
     DocStringConst(ArcIntern<SmolStr>),
     DocIntegerConst(i64),
     Namespace(ArcIntern<SmolStr>),
+    Variadic(Arc<LuaType>),
 }
 
 impl PartialEq for LuaType {
@@ -104,6 +105,7 @@ impl PartialEq for LuaType {
             (LuaType::DocStringConst(a), LuaType::DocStringConst(b)) => a == b,
             (LuaType::DocIntegerConst(a), LuaType::DocIntegerConst(b)) => a == b,
             (LuaType::Namespace(a), LuaType::Namespace(b)) => a == b,
+            (LuaType::Variadic(a), LuaType::Variadic(b)) => a == b,
             _ => false, // 不同变体之间不相等
         }
     }
@@ -178,6 +180,7 @@ impl Hash for LuaType {
             LuaType::DocStringConst(a) => (40, a).hash(state),
             LuaType::DocIntegerConst(a) => (41, a).hash(state),
             LuaType::Namespace(a) => (42, a).hash(state),
+            LuaType::Variadic(a) => (43, a).hash(state),
         }
     }
 }
@@ -366,6 +369,7 @@ impl LuaType {
             LuaType::MuliReturn(multi) => multi.contain_tpl(),
             LuaType::ExistField(field) => field.contain_tpl(),
             LuaType::TableGeneric(params) => params.iter().any(|p| p.contain_tpl()),
+            LuaType::Variadic(inner) => inner.contain_tpl(),
             LuaType::TplRef(_) => true,
             LuaType::StrTplRef(_) => true,
             LuaType::FuncTplRef(_) => true,
@@ -376,6 +380,10 @@ impl LuaType {
     pub fn is_namespace(&self) -> bool {
         matches!(self, LuaType::Namespace(_))
     }
+
+    pub fn is_variadic(&self) -> bool {
+        matches!(self, LuaType::Variadic(_))
+    }
 }
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
@@ -704,6 +712,13 @@ impl LuaMultiReturn {
         }
     }
 
+    pub fn get_len(&self) -> usize {
+        match self {
+            LuaMultiReturn::Multi(types) => types.len(),
+            LuaMultiReturn::Base(_) => 1,
+        }
+    }
+
     pub fn contain_tpl(&self) -> bool {
         match self {
             LuaMultiReturn::Multi(types) => types.iter().any(|t| t.contain_tpl()),

crates/code_analysis/src/semantic/infer/infer_call.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{ops::Deref, sync::Arc};
 
 use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr, LuaSyntaxKind};
 
@@ -334,6 +334,9 @@ fn unwrapp_return_type(
 
             return multi.get_type(0).cloned();
         }
+        LuaType::Variadic(inner) => {
+            return Some(inner.deref().clone());
+        }
         LuaType::SelfInfer => {
             let prefix_expr = call_expr.get_prefix_expr();
             if let Some(prefix_expr) = prefix_expr {

crates/code_analysis/src/semantic/instantiate/tpl_pattern.rs

@@ -4,8 +4,7 @@ use emmylua_parser::{LuaAstNode, LuaSyntaxId, LuaSyntaxNode, LuaTableExpr};
 use smol_str::SmolStr;
 
 use crate::{
-    db_index::{DbIndex, LuaGenericType, LuaType},
-    semantic::{infer_expr, LuaInferConfig}, LuaUnionType,
+    db_index::{DbIndex, LuaGenericType, LuaType}, semantic::{infer_expr, LuaInferConfig}, LuaFunctionType, LuaUnionType
 };
 
 #[allow(unused)]
@@ -48,6 +47,9 @@ pub fn tpl_pattern_match(
         LuaType::Union(union) => {
             union_tpl_pattern_match(db, config, root, union, target, result);
         }
+        LuaType::DocFunction(doc_func) => {
+            func_tpl_pattern_match(db, config, root, doc_func, target, result);
+        }
         _ => {}
     }
 
@@ -162,5 +164,27 @@ fn union_tpl_pattern_match(
         tpl_pattern_match(db, config, root, u, target, result);
     }
 
+    Some(())
+}
+
+#[allow(unused)]
+fn func_tpl_pattern_match(
+    db: &DbIndex,
+    config: &mut LuaInferConfig,
+    root: &LuaSyntaxNode,
+    doc_func: &LuaFunctionType,
+    target: &LuaType,
+    result: &mut HashMap<usize, LuaType>,
+) -> Option<()> {
+    match target {
+        LuaType::DocFunction(target_doc_func) => {
+            // todo
+        }
+        LuaType::Signature(signature_id) => {
+            // todo
+        }
+        _ => {}
+    }
+
     Some(())
 }