调整测试

Author: xuhuanzy

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

@@ -333,7 +333,7 @@ pub fn analyze_func_generic(analyzer: &mut DocAnalyzer, tag: LuaDocTagGeneric) -
             params_result.push(GenericParam::new(
                 SmolStr::new(name.as_str()),
                 type_ref.clone(),
-                false,
+                param.is_variadic(),
             ));
             param_info.push((name, type_ref));
         }

crates/emmylua_code_analysis/src/compilation/test/generic_test.rs

@@ -407,16 +407,15 @@ mod test {
     fn test_issue_787() {
         let mut ws = VirtualWorkspace::new();
 
-        // TODO: 我们应该删除`T...`功能, 改为泛型`T`遇到 ... 会自动收集其所有参数合并为 Tuple 类型
         ws.def(
             r#"
             ---@class Wrapper<T>
 
             ---@alias UnwrapUnion<T> { [K in keyof T]: T[K] extends Wrapper<infer U> and U or unknown; }
 
-            ---@generic T
+            ---@generic T...
             ---@param ... T...
-            ---@return UnwrapUnion<[T...]>
+            ---@return UnwrapUnion<T>...
             function unwrap(...) end
             "#,
         );

crates/emmylua_code_analysis/src/semantic/generic/instantiate_func_generic.rs

@@ -47,9 +47,9 @@ pub fn instantiate_func_generic(
     });
 
     let origin_params = func.get_params();
-    let mut func_param_types: Vec<_> = origin_params
+    let mut func_params: Vec<_> = origin_params
         .iter()
-        .map(|(_, t)| t.clone().unwrap_or(LuaType::Unknown))
+        .map(|(name, t)| (name.clone(), t.clone().unwrap_or(LuaType::Unknown)))
         .collect();
 
     let arg_exprs = call_expr
@@ -72,18 +72,18 @@ pub fn instantiate_func_generic(
         let colon_define = func.is_colon_define();
         match (colon_define, colon_call) {
             (true, false) => {
-                func_param_types.insert(0, LuaType::Any);
+                func_params.insert(0, ("self".to_string(), LuaType::Any));
             }
             (false, true) => {
-                if !func_param_types.is_empty() {
-                    func_param_types.remove(0);
+                if !func_params.is_empty() {
+                    func_params.remove(0);
                 }
             }
             _ => {}
         }
 
         let mut unresolve_tpls = vec![];
-        for i in 0..func_param_types.len() {
+        for i in 0..func_params.len() {
             if i >= arg_exprs.len() {
                 break;
             }
@@ -92,7 +92,7 @@ pub fn instantiate_func_generic(
                 break;
             }
 
-            let func_param_type = &func_param_types[i];
+            let (_, func_param_type) = &func_params[i];
             let call_arg_expr = &arg_exprs[i];
             if !func_param_type.contain_tpl() {
                 continue;
@@ -107,6 +107,8 @@ pub fn instantiate_func_generic(
             }
 
             let arg_type = infer_expr(db, context.cache, call_arg_expr.clone())?;
+            dbg!(&func_param_type);
+            dbg!(&arg_type);
 
             match (func_param_type, &arg_type) {
                 (LuaType::Variadic(variadic), _) => {
@@ -119,9 +121,14 @@ pub fn instantiate_func_generic(
                     break;
                 }
                 (_, LuaType::Variadic(variadic)) => {
+                    let func_param_types = func_params[i..]
+                        .iter()
+                        .map(|(_, t)| t)
+                        .cloned()
+                        .collect::<Vec<_>>();
                     multi_param_tpl_pattern_match_multi_return(
                         &mut context,
-                        &func_param_types[i..],
+                        &func_param_types,
                         variadic,
                     )?;
                     break;
@@ -145,6 +152,10 @@ pub fn instantiate_func_generic(
         substitutor.add_self_type(self_type);
     }
     if let LuaType::DocFunction(f) = instantiate_doc_function(db, func, &substitutor) {
+        dbg!(&func);
+        dbg!(&substitutor);
+        dbg!(&call_expr);
+        dbg!(&f);
         Ok(f.deref().clone())
     } else {
         Ok(func.clone())

crates/emmylua_code_analysis/src/semantic/generic/instantiate_type_generic.rs

@@ -188,7 +188,21 @@ pub fn instantiate_doc_function(
     // 将 substitutor 中存储的类型的 def 转为 ref
     let mut modified_substitutor = substitutor.clone();
     modified_substitutor.convert_def_to_ref();
-    let inst_ret_type = instantiate_type_generic(db, tpl_ret, &modified_substitutor);
+    let mut inst_ret_type = instantiate_type_generic(db, tpl_ret, &modified_substitutor);
+    // 对于可变返回值, 如果实例化是 tuple, 那么我们将展开 tuple
+    if let LuaType::Variadic(_) = &&tpl_ret
+        && let LuaType::Tuple(tuple) = &inst_ret_type
+    {
+        match tuple.len() {
+            0 => {}
+            1 => inst_ret_type = tuple.get_types()[0].clone(),
+            _ => {
+                inst_ret_type =
+                    LuaType::Variadic(VariadicType::Multi(tuple.get_types().to_vec()).into())
+            }
+        }
+    }
+
     LuaType::DocFunction(
         LuaFunctionType::new(async_state, colon_define, new_params, inst_ret_type).into(),
     )
@@ -302,6 +316,7 @@ fn instantiate_table_generic(
 }
 
 fn instantiate_tpl_ref(_: &DbIndex, tpl: &GenericTpl, substitutor: &TypeSubstitutor) -> LuaType {
+    // 泛型是否以`T...`定义(非使用), 以`T...`定义的泛型我们应该将其视为一个元组
     if tpl.is_variadic() {
         if let Some(generics) = substitutor.get_variadic(tpl.get_tpl_id()) {
             if generics.len() == 1 {
@@ -745,6 +760,9 @@ fn instantiate_mapped_type(
         .type_constraint
         .as_ref()
         .map(|ty| instantiate_type_generic(db, ty, substitutor));
+    dbg!(&mapped);
+    dbg!(&substitutor);
+    dbg!(&constraint);
 
     if let Some(constraint) = constraint {
         let mut key_types = Vec::new();
@@ -777,10 +795,10 @@ fn instantiate_mapped_type(
         if !fields.is_empty() || !index_access.is_empty() {
             if constraint.is_tuple() {
                 let types = fields.into_iter().map(|(_, ty)| ty).collect();
-                return LuaType::Variadic(VariadicType::Multi(types).into());
-                // return LuaType::Tuple(
-                //     LuaTupleType::new(types, LuaTupleStatus::InferResolve).into(),
-                // );
+                // return LuaType::Variadic(VariadicType::Multi(types).into());
+                return LuaType::Tuple(
+                    LuaTupleType::new(types, LuaTupleStatus::InferResolve).into(),
+                );
             }
             let field_map: HashMap<LuaMemberKey, LuaType> = fields.into_iter().collect();
             return LuaType::Object(LuaObjectType::new_with_fields(field_map, index_access).into());