refactor multi to variadic

Author: CppCXY

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

@@ -69,16 +69,6 @@ pub fn add_member(db: &mut DbIndex, owner: LuaMemberOwner, member_id: LuaMemberI
     db.get_member_index_mut()
         .add_member_to_owner(owner.clone(), member_id);
 
-    // let item = db.get_member_index().get_member_item_by_member_id(member_id)?;
-    // if item.is_one() {
-    //     return Some(())
-    // }
-
-    // let resolve_member_id = item.resolve_type_owner_member_id(db)?;
-    // if resolve_member_id != member_id {
-    //     return None;
-    // }
-
     Some(())
 }
 

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

@@ -94,7 +94,7 @@ pub fn analyze_field(analyzer: &mut DocAnalyzer, tag: LuaDocTagField) -> Option<
                         ),
                         ("key".to_string(), Some(key_type_ref)),
                     ],
-                    vec![field_type],
+                    field_type,
                 ))),
             );
             analyzer.db.get_operator_index_mut().add_operator(operator);
@@ -178,7 +178,7 @@ pub fn analyze_operator(analyzer: &mut DocAnalyzer, tag: LuaDocTagOperator) -> O
             false,
             false,
             operands,
-            vec![return_type],
+            return_type,
         ))),
     );
 

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

@@ -15,7 +15,7 @@ use crate::{
         LuaIntersectionType, LuaObjectType, LuaStringTplType, LuaTupleType, LuaType, LuaUnionType,
     },
     DiagnosticCode, GenericTpl, InFiled, LuaAliasCallKind, LuaMultiLineUnion, LuaTypeDeclId,
-    TypeOps,
+    TypeOps, VariadicType,
 };
 
 use super::{preprocess_description, DocAnalyzer};
@@ -450,8 +450,16 @@ fn infer_func_type(analyzer: &mut DocAnalyzer, func: &LuaDocFuncType) -> LuaType
         }
     }
 
+    let return_type = if return_types.len() == 1 {
+        return_types[0].clone()
+    } else if return_types.len() > 1 {
+        LuaType::Variadic(VariadicType::Multi(return_types).into())
+    } else {
+        LuaType::Nil
+    };
+
     LuaType::DocFunction(
-        LuaFunctionType::new(is_async, is_colon, params_result, return_types).into(),
+        LuaFunctionType::new(is_async, is_colon, params_result, return_type).into(),
     )
 }
 
@@ -536,8 +544,8 @@ fn infer_variadic_type(
     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(), node);
-
-    Some(LuaType::Variadic(base.into()))
+    let variadic = VariadicType::Base(base.clone());
+    Some(LuaType::Variadic(variadic.into()))
 }
 
 fn infer_multi_line_union_type(

crates/emmylua_code_analysis/src/compilation/analyzer/lua/closure.rs

@@ -8,8 +8,8 @@ use crate::{
         UnResolveParentClosureParams, UnResolveReturn,
     },
     db_index::{LuaDocReturnInfo, LuaSignatureId},
-    infer_expr, DbIndex, InferFailReason, LuaInferCache, LuaMultiReturn, LuaType,
-    SignatureReturnStatus, TypeOps,
+    infer_expr, DbIndex, InferFailReason, LuaInferCache, LuaType, SignatureReturnStatus, TypeOps,
+    VariadicType,
 };
 
 use super::{func_body::analyze_func_body_returns, LuaAnalyzer, LuaReturnPoint};
@@ -211,7 +211,7 @@ pub fn analyze_return_point(
                     let expr_type = infer_expr(db, cache, expr.clone())?;
                     multi_return.push(expr_type);
                 }
-                let typ = LuaType::MuliReturn(LuaMultiReturn::Multi(multi_return).into());
+                let typ = LuaType::Variadic(VariadicType::Multi(multi_return).into());
                 return_type = TypeOps::Union.apply(&return_type, &typ);
             }
             LuaReturnPoint::Nil => {

crates/emmylua_code_analysis/src/compilation/analyzer/lua/for_range_stat.rs

@@ -22,7 +22,7 @@ pub fn analyze_for_range_stat(
             let iter_doc_func = infer_for_range_iter_expr_func(analyzer.db, first_iter_type);
 
             if let Some(doc_func) = iter_doc_func {
-                let multi_return = doc_func.get_multi_return();
+                let multi_return = doc_func.get_variadic_ret();
                 let mut idx = 0;
                 for var_name in var_name_list {
                     let position = var_name.get_position();

crates/emmylua_code_analysis/src/compilation/analyzer/lua/module.rs

@@ -34,7 +34,7 @@ pub fn analyze_chunk_return(analyzer: &mut LuaAnalyzer, chunk: LuaChunk) -> Opti
                     .get_module_index_mut()
                     .get_module_mut(analyzer.file_id)?;
                 match expr_type {
-                    LuaType::MuliReturn(multi) => {
+                    LuaType::Variadic(multi) => {
                         let ty = multi.get_type(0)?;
                         module_info.export_type = Some(ty.clone());
                     }

crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs

@@ -35,21 +35,22 @@ pub fn analyze_local_stat(analyzer: &mut LuaAnalyzer, local_stat: LuaLocalStat)
     for i in 0..name_count {
         let name = name_list.get(i)?;
         let position = name.get_position();
-        let expr = expr_list.get(i);
-        if expr.is_none() {
+        let expr = if let Some(expr) = expr_list.get(i) {
+            expr.clone()
+        } else {
             break;
-        }
-        let expr = expr?;
-        match analyzer.infer_expr(expr) {
+        };
+
+        match analyzer.infer_expr(&expr) {
             Ok(mut expr_type) => {
-                if let LuaType::MuliReturn(multi) = expr_type {
+                if let LuaType::Variadic(multi) = expr_type {
                     expr_type = multi.get_type(0)?.clone();
                 }
                 let decl_id = LuaDeclId::new(analyzer.file_id, position);
                 // 当`call`参数包含表时, 表可能未被分析, 需要延迟
                 if let LuaType::Instance(instance) = &expr_type {
                     if instance.get_base().is_unknown() {
-                        if call_expr_has_effect_table_arg(expr).is_some() {
+                        if call_expr_has_effect_table_arg(&expr).is_some() {
                             let unresolve = UnResolveDecl {
                                 file_id: analyzer.file_id,
                                 decl_id,
@@ -62,9 +63,7 @@ pub fn analyze_local_stat(analyzer: &mut LuaAnalyzer, local_stat: LuaLocalStat)
                         }
                     }
                 }
-                if let LuaType::Variadic(variadic) = expr_type {
-                    expr_type = variadic.as_ref().clone();
-                }
+
                 bind_type(
                     analyzer.db,
                     decl_id.into(),
@@ -99,21 +98,17 @@ pub fn analyze_local_stat(analyzer: &mut LuaAnalyzer, local_stat: LuaLocalStat)
         if let Some(last_expr) = last_expr {
             match analyzer.infer_expr(last_expr) {
                 Ok(last_expr_type) => {
-                    if let LuaType::MuliReturn(multi) = last_expr_type {
+                    if let LuaType::Variadic(variadic) = last_expr_type {
                         for i in expr_count..name_count {
                             let name = name_list.get(i)?;
                             let position = name.get_position();
                             let decl_id = LuaDeclId::new(analyzer.file_id, position);
-                            let ret_type = multi.get_type(i - expr_count + 1);
-                            if let Some(ty) = ret_type {
-                                let mut final_type = ty.clone();
-                                if let LuaType::Variadic(variadic) = final_type {
-                                    final_type = variadic.as_ref().clone();
-                                }
+                            let ret_type = variadic.get_type(i - expr_count + 1);
+                            if let Some(ret_type) = ret_type {
                                 bind_type(
                                     analyzer.db,
                                     decl_id.into(),
-                                    LuaTypeCache::InferType(final_type),
+                                    LuaTypeCache::InferType(ret_type.clone()),
                                 );
                             } else {
                                 analyzer.db.get_type_index_mut().bind_type(
@@ -271,7 +266,7 @@ pub fn analyze_assign_stat(analyzer: &mut LuaAnalyzer, assign_stat: LuaAssignSta
 
         let expr_type = match analyzer.infer_expr(expr) {
             Ok(expr_type) => match expr_type {
-                LuaType::MuliReturn(multi) => multi.get_type(0)?.clone(),
+                LuaType::Variadic(multi) => multi.get_type(0)?.clone(),
                 _ => expr_type,
             },
             Err(InferFailReason::None) => LuaType::Unknown,
@@ -355,15 +350,9 @@ fn assign_merge_type_owner_and_expr_type(
     idx: usize,
 ) -> Option<()> {
     let mut expr_type = expr_type.clone();
-    if let LuaType::MuliReturn(multi) = expr_type {
+    if let LuaType::Variadic(multi) = expr_type {
         expr_type = multi.get_type(idx).unwrap_or(&LuaType::Nil).clone();
     }
-    match &expr_type {
-        LuaType::Variadic(variadic) => {
-            expr_type = variadic.as_ref().clone();
-        }
-        _ => {}
-    }
 
     bind_type(analyzer.db, type_owner, LuaTypeCache::InferType(expr_type));
 

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve.rs

@@ -37,7 +37,7 @@ pub fn try_resolve_decl(
     };
     let decl_id = decl.decl_id;
     let expr_type = match &expr_type {
-        LuaType::MuliReturn(multi) => multi
+        LuaType::Variadic(multi) => multi
             .get_type(decl.ret_idx)
             .cloned()
             .unwrap_or(LuaType::Unknown),
@@ -96,7 +96,7 @@ pub fn try_resolve_member(
         };
 
         let expr_type = match &expr_type {
-            LuaType::MuliReturn(multi) => multi
+            LuaType::Variadic(multi) => multi
                 .get_type(unresolve_member.ret_idx)
                 .cloned()
                 .unwrap_or(LuaType::Unknown),
@@ -221,7 +221,7 @@ pub fn try_resolve_module(
     };
 
     let expr_type = match &expr_type {
-        LuaType::MuliReturn(multi) => multi.get_type(0).cloned().unwrap_or(LuaType::Unknown),
+        LuaType::Variadic(multi) => multi.get_type(0).cloned().unwrap_or(LuaType::Unknown),
         _ => expr_type,
     };
     let module_info = db.get_module_index_mut().get_module_mut(module.file_id)?;
@@ -281,7 +281,7 @@ pub fn try_resolve_iter_var(
         }
     };
 
-    let multi_return = func.get_multi_return();
+    let multi_return = func.get_variadic_ret();
     let mut iter_type = multi_return
         .get_type(iter_var.ret_idx)
         .cloned()

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/resolve_closure.rs

@@ -153,7 +153,7 @@ pub fn try_resolve_closure_return(
         _ => {}
     }
 
-    let expr_closure_return = if let Some(param_type) = call_doc_func.get_params().get(param_idx) {
+    let ret_type = if let Some(param_type) = call_doc_func.get_params().get(param_idx) {
         if let Some(LuaType::DocFunction(func)) = &param_type.1 {
             func.get_ret()
         } else {
@@ -167,17 +167,15 @@ pub fn try_resolve_closure_return(
         .get_signature_index_mut()
         .get_mut(&closure_return.signature_id)?;
 
-    if expr_closure_return.iter().any(|it| it.contain_tpl()) {
+    if ret_type.contain_tpl() {
         return try_convert_to_func_body_infer(db, cache, closure_return);
     }
 
-    for ret_type in expr_closure_return {
-        signature.return_docs.push(LuaDocReturnInfo {
-            name: None,
-            type_ref: ret_type.clone(),
-            description: None,
-        });
-    }
+    signature.return_docs.push(LuaDocReturnInfo {
+        name: None,
+        type_ref: ret_type.clone(),
+        description: None,
+    });
 
     signature.resolve_return = SignatureReturnStatus::DocResolve;
     Some(true)
@@ -286,12 +284,7 @@ pub fn try_resolve_closure_parent_params(
             let signature = db.get_signature_index().get(id);
 
             if let Some(signature) = signature {
-                let fake_doc_function = LuaFunctionType::new(
-                    signature.is_async,
-                    signature.is_colon_define,
-                    signature.get_type_params(),
-                    signature.get_return_types(),
-                );
+                let fake_doc_function = signature.to_doc_func_type();
                 resolve_doc_function(db, closure_params, &fake_doc_function, self_type)
             } else {
                 Some(true)
@@ -356,13 +349,11 @@ fn resolve_doc_function(
     {
         signature.return_docs.clear();
         signature.resolve_return = SignatureReturnStatus::DocResolve;
-        for ret in doc_func.get_ret() {
-            signature.return_docs.push(LuaDocReturnInfo {
-                name: None,
-                type_ref: ret.clone(),
-                description: None,
-            });
-        }
+        signature.return_docs.push(LuaDocReturnInfo {
+            name: None,
+            type_ref: doc_func.get_ret().clone(),
+            description: None,
+        });
     }
 
     Some(true)

crates/emmylua_code_analysis/src/db_index/operators/lua_operator.rs

@@ -76,13 +76,7 @@ impl LuaOperator {
 
     pub fn get_result(&self, db: &DbIndex) -> Result<LuaType, InferFailReason> {
         match &self.func {
-            OperatorFunction::Func(func) => {
-                let return_types = func.get_ret();
-                if return_types.is_empty() {
-                    return Ok(LuaType::Any);
-                }
-                return Ok(return_types[0].clone());
-            }
+            OperatorFunction::Func(func) => Ok(func.get_ret().clone()),
             OperatorFunction::Signature(signature_id) => {
                 let signature = db.get_signature_index().get(signature_id);
                 if let Some(signature) = signature {