make unpack support array

Author: CppCXY

crates/emmylua_code_analysis/src/semantic/instantiate/instantiate_class_generic.rs

@@ -68,6 +68,7 @@ fn instantiate_tuple(db: &DbIndex, tuple: &LuaTupleType, substitutor: &TypeSubst
                             }
                         }
                         SubstitutorValue::Type(ty) => new_types.push(ty.clone()),
+                        SubstitutorValue::MultiBase(base) => new_types.push(base.clone()),
                     }
                 }
             }
@@ -135,7 +136,17 @@ pub fn instantiate_doc_function(
                                     new_returns.push(typ.clone());
                                 }
                             }
-                            _ => {}
+                            SubstitutorValue::Params(params) => {
+                                for (_, ty) in params {
+                                    new_returns.push(ty.clone().unwrap_or(LuaType::Unknown));
+                                }
+                            }
+                            SubstitutorValue::Type(ty) => new_returns.push(ty.clone()),
+                            SubstitutorValue::MultiBase(base) => {
+                                new_returns.push(LuaType::MuliReturn(
+                                    LuaMultiReturn::Base(base.clone()).into(),
+                                ));
+                            }
                         }
                     }
                 }
@@ -264,6 +275,7 @@ fn instantiate_tpl_ref(_: &DbIndex, tpl: &GenericTpl, substitutor: &TypeSubstitu
                     .clone()
                     .unwrap_or(LuaType::Unknown);
             }
+            SubstitutorValue::MultiBase(base) => return base.clone(),
         }
     }
 
@@ -505,6 +517,9 @@ fn instantiate_variadic_type(
                         .collect::<Vec<_>>();
                     return LuaType::MuliReturn(LuaMultiReturn::Multi(types).into());
                 }
+                SubstitutorValue::MultiBase(base) => {
+                    return LuaType::MuliReturn(LuaMultiReturn::Base(base.clone()).into());
+                }
             }
         }
     }

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

@@ -63,4 +63,24 @@ mod test {
         let expected = ws.expr_ty("2");
         assert_eq!(h, expected);
     }
+
+    #[test]
+    fn test_unpack() {
+        let mut ws = crate::VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(r#"
+        local h ---@type number[]
+        a, b, c = table.unpack(h)
+        "#);
+
+        let a = ws.expr_ty("a");
+        let expected = ws.ty("number");
+        let b = ws.expr_ty("b");
+        let expected_b = ws.ty("number");
+        let c = ws.expr_ty("c");
+        let expected_c = ws.ty("number");
+        assert_eq!(a, expected);
+        assert_eq!(b, expected_b);
+        assert_eq!(c, expected_c);
+    }
 }

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

@@ -4,7 +4,9 @@ use emmylua_parser::{LuaAstNode, LuaSyntaxId, LuaSyntaxNode, LuaTableExpr};
 use smol_str::SmolStr;
 
 use crate::{
-    db_index::{DbIndex, LuaGenericType, LuaType}, semantic::{infer_expr, LuaInferConfig}, LuaFunctionType, LuaTupleType, LuaUnionType
+    db_index::{DbIndex, LuaGenericType, LuaType},
+    semantic::{infer_expr, LuaInferConfig},
+    LuaFunctionType, LuaTupleType, LuaUnionType,
 };
 
 use super::type_substitutor::TypeSubstitutor;
@@ -346,11 +348,18 @@ fn tuple_tpl_pattern_match(
                 tpl_pattern_match(db, config, root, tpl_type, target_type, substitutor);
             }
         }
-        // LuaType::Array(target_array_base) => {
-            
-        // }
+        LuaType::Array(target_array_base) => {
+            let tupl_tuple_types = tpl_tuple.get_types();
+            let last_type = tupl_tuple_types.last()?;
+            if let LuaType::Variadic(inner) = last_type {
+                if let LuaType::TplRef(tpl_ref) = inner.deref() {
+                    let tpl_id = tpl_ref.get_tpl_id();
+                    substitutor.insert_multi_base(tpl_id, target_array_base.deref().clone());
+                }
+            }
+        }
         _ => {}
     }
 
     Some(())
-}
+}

crates/emmylua_code_analysis/src/semantic/instantiate/type_substitutor.rs

@@ -65,6 +65,15 @@ impl TypeSubstitutor {
             .insert(tpl_id, SubstitutorValue::MultiTypes(types));
     }
 
+    pub fn insert_multi_base(&mut self, tpl_id: GenericTplId, type_base: LuaType) {
+        if self.tpl_replace_map.contains_key(&tpl_id) {
+            return;
+        }
+
+        self.tpl_replace_map
+            .insert(tpl_id, SubstitutorValue::MultiBase(type_base));
+    }
+
     pub fn get(&self, tpl_id: GenericTplId) -> Option<&SubstitutorValue> {
         self.tpl_replace_map.get(&tpl_id)
     }
@@ -85,4 +94,5 @@ pub enum SubstitutorValue {
     Type(LuaType),
     Params(Vec<(String, Option<LuaType>)>),
     MultiTypes(Vec<LuaType>),
+    MultiBase(LuaType),
 }