移除 ...: T 默认解析为 Tuple

Author: xuhuanzy

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

@@ -416,7 +416,7 @@ mod test {
 
             ---@generic T
             ---@param ... T...
-            ---@return UnwrapUnion<T>...
+            ---@return UnwrapUnion<[T...]>
             function unwrap(...) end
             "#,
         );

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

@@ -4,8 +4,7 @@ use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr};
 use internment::ArcIntern;
 
 use crate::{
-    GenericTpl, GenericTplId, LuaFunctionType, LuaGenericType, LuaTupleStatus, LuaTupleType,
-    TypeVisitTrait,
+    GenericTpl, GenericTplId, LuaFunctionType, LuaGenericType, TypeVisitTrait,
     db_index::{DbIndex, LuaType},
     semantic::{
         LuaInferCache,
@@ -116,10 +115,6 @@ pub fn instantiate_func_generic(
                         let arg_type = infer_expr(db, context.cache, arg_expr.clone())?;
                         arg_types.push(constant_decay(arg_type));
                     }
-                    // 剩余参数应该推断为元组类型
-                    arg_types = vec![LuaType::Tuple(
-                        LuaTupleType::new(arg_types, LuaTupleStatus::InferResolve).into(),
-                    )];
                     variadic_tpl_pattern_match(&mut context, variadic, &arg_types)?;
                     break;
                 }
@@ -149,7 +144,6 @@ pub fn instantiate_func_generic(
     if contain_self && let Some(self_type) = infer_self_type(db, cache, &call_expr) {
         substitutor.add_self_type(self_type);
     }
-
     if let LuaType::DocFunction(f) = instantiate_doc_function(db, func, &substitutor) {
         Ok(f.deref().clone())
     } else {

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

@@ -134,29 +134,36 @@ fn instantiate_select_call(source: &LuaType, index: &LuaType) -> LuaType {
         _ => return LuaType::Unknown,
     };
 
+    let multi_return = if let LuaType::Variadic(multi) = source {
+        multi.deref()
+    } else {
+        &VariadicType::Base(source.clone())
+    };
+
     match num_or_len {
-        NumOrLen::Num(i) => match source {
-            LuaType::Tuple(tuple) => {
-                if let Some(first) = tuple.get_type(0) {
-                    if first.is_variadic() {
-                        return first.clone();
-                    }
-                }
-                // 返回元组中从 i 开始的所有类型
-                let mut types = Vec::new();
-                for ty in tuple.get_types().iter().skip(i as usize - 1) {
-                    types.push(ty.clone());
+        NumOrLen::Num(i) => match multi_return {
+            VariadicType::Base(_) => LuaType::Variadic(multi_return.clone().into()),
+            VariadicType::Multi(_) => {
+                let Some(total_len) = multi_return.get_min_len() else {
+                    return source.clone();
+                };
+
+                let start = if i < 0 { total_len as i64 + i } else { i - 1 };
+                if start < 0 || start >= (total_len as i64) {
+                    return source.clone();
                 }
 
-                LuaType::Tuple(LuaTupleType::new(types, LuaTupleStatus::InferResolve).into())
+                let multi = multi_return.get_new_variadic_from(start as usize);
+                LuaType::Variadic(multi.into())
             }
-            _ => LuaType::Unknown,
         },
         NumOrLen::Len => {
-            if let LuaType::Tuple(tuple) = source {
-                return LuaType::IntegerConst(tuple.get_types().len() as i64);
+            let len = multi_return.get_min_len();
+            if let Some(len) = len {
+                LuaType::IntegerConst(len as i64)
+            } else {
+                LuaType::Integer
             }
-            LuaType::Integer
         }
         NumOrLen::LenUnknown => LuaType::Integer,
     }

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

@@ -153,14 +153,6 @@ pub fn instantiate_doc_function(
                                         new_params.push((param_name, Some(typ.clone())));
                                     }
                                 }
-                                // 剩余参数会被压制成元组, 我们需要展开他
-                                SubstitutorValue::Type(LuaType::Tuple(tuple)) => {
-                                    for (i, typ) in tuple.get_types().iter().enumerate() {
-                                        let param_name = format!("args_{}", i);
-                                        new_params.push((param_name, Some(typ.clone())));
-                                    }
-                                    continue;
-                                }
                                 _ => {
                                     new_params.push((
                                         "...".to_string(),
@@ -196,71 +188,7 @@ pub fn instantiate_doc_function(
     // 将 substitutor 中存储的类型的 def 转为 ref
     let mut modified_substitutor = substitutor.clone();
     modified_substitutor.convert_def_to_ref();
-    let mut inst_ret_type = instantiate_type_generic(db, tpl_ret, &modified_substitutor);
-    // 如果返回值可变的, 且对应的实例化对应值是 tuple, 那么我们将其展开
-    // TODO: 现在的实现过于复杂, 我们应该预处理可变参数
-    match (tpl_ret, &inst_ret_type) {
-        (LuaType::Variadic(tpl_ret), LuaType::Variadic(inst_ret)) => {
-            match (tpl_ret.deref(), inst_ret.deref()) {
-                (VariadicType::Base(tpl_base), VariadicType::Base(inst_base)) => {
-                    if tpl_base.is_variadic()
-                        && let LuaType::Tuple(inst_tuple) = inst_base
-                    {
-                        inst_ret_type = LuaType::Variadic(
-                            VariadicType::Multi(inst_tuple.get_types().to_vec()).into(),
-                        );
-                    }
-                }
-                (VariadicType::Multi(tpl_multi), VariadicType::Multi(inst_multi)) => {
-                    let tpl_last = tpl_multi.last().unwrap_or(&LuaType::Unknown);
-                    let inst_last = inst_multi.last().unwrap_or(&LuaType::Unknown);
-                    if tpl_last.is_variadic()
-                        && let LuaType::Tuple(inst_tuple) = inst_last
-                    {
-                        let mut new_types = Vec::new();
-                        for ty in inst_multi {
-                            new_types.push(ty.clone());
-                        }
-                        new_types.pop();
-                        new_types.extend_from_slice(inst_tuple.get_types());
-                        inst_ret_type = LuaType::Variadic(VariadicType::Multi(new_types).into());
-                    }
-                }
-                _ => {}
-            }
-        }
-        (LuaType::Variadic(tpl_ret), LuaType::Tuple(inst_tuple)) => {
-            if let VariadicType::Base(_) = tpl_ret.deref() {
-                let mut new_types = Vec::new();
-                new_types.extend_from_slice(inst_tuple.get_types());
-                inst_ret_type = LuaType::Variadic(VariadicType::Multi(new_types).into());
-            }
-        }
-        (_, LuaType::Variadic(inst_ret)) => {
-            if let VariadicType::Base(base) = inst_ret.deref() {
-                if let LuaType::Tuple(tuple) = base {
-                    match tuple.len() {
-                        0 => inst_ret_type = LuaType::Unknown,
-                        1 => inst_ret_type = tuple.get_types()[0].clone(),
-                        _ => {
-                            inst_ret_type = LuaType::Variadic(
-                                VariadicType::Multi(tuple.get_types().to_vec()).into(),
-                            )
-                        }
-                    }
-                }
-            }
-        }
-        (_, LuaType::Tuple(tuple)) => match tuple.len() {
-            0 => inst_ret_type = LuaType::Unknown,
-            1 => inst_ret_type = tuple.get_types()[0].clone(),
-            _ => {
-                inst_ret_type =
-                    LuaType::Variadic(VariadicType::Multi(tuple.get_types().to_vec()).into())
-            }
-        },
-        _ => {}
-    }
+    let inst_ret_type = instantiate_type_generic(db, tpl_ret, &modified_substitutor);
     LuaType::DocFunction(
         LuaFunctionType::new(async_state, colon_define, new_params, inst_ret_type).into(),
     )
@@ -849,9 +777,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::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());

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

@@ -32,19 +32,7 @@ mod test {
 
     #[test]
     fn test_select_type() {
-        let mut ws = crate::VirtualWorkspace::new();
-        ws.def(
-            r#"
-        ---@alias std.Select<T, StartOrLen> unknown
-        ---@alias std.ConstTpl<T> unknown
-
-        ---@generic T, Num: integer | '#'
-        ---@param index std.ConstTpl<Num>
-        ---@param ... T...
-        ---@return std.Select<T..., Num>
-        function select(index, ...) end
-        "#,
-        );
+        let mut ws = crate::VirtualWorkspace::new_with_init_std_lib();
         ws.def(
             r#"
         ---@param ... string

crates/emmylua_parser/src/grammar/doc/test.rs

@@ -3147,4 +3147,12 @@ Syntax(Chunk)@0..110
 "#;
         assert_ast_eq!(code, result);
     }
+
+    #[test]
+    fn test_alias_conditional_infer_dots() {
+        let code = r#"
+        ---@alias ConstructorParameters<T> T extends (fun(infer: infer P): any) and P... or unknown
+        "#;
+        print_ast(code);
+    }
 }