fix rebase && fix generic param type match

Author: xuhuanzy

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

@@ -155,6 +155,7 @@ pub fn infer_for_range_iter_expr_func(
         cache,
         substitutor: &mut substitutor,
         root: root,
+        call_expr: None,
     };
     let params = doc_function
         .get_params()

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

@@ -67,4 +67,33 @@ mod test {
         let expected = ws.ty("fun(b:string, c:table)");
         assert_eq!(bar_ty, expected);
     }
+
+    #[test]
+    fn test_generic_params() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@class Observable<T>
+            ---@class Subject<T>: Observable<T>
+
+            ---@generic T
+            ---@param ... Observable<T>
+            ---@return Observable<T>
+            function concat(...)
+            end
+            "#,
+        );
+
+        ws.def(
+            r#"
+            ---@type Subject<number>
+            local s1
+            A = concat(s1)
+            "#,
+        );
+
+        let a_ty = ws.expr_ty("A");
+        let expected = ws.ty("Observable<number>");
+        assert_eq!(a_ty, expected);
+    }
 }

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

@@ -1,4 +1,4 @@
-use std::{collections::HashSet, ops::Deref};
+use std::{collections::HashSet, ops::Deref, sync::Arc};
 
 use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr};
 use internment::ArcIntern;
@@ -17,7 +17,7 @@ use crate::{
         infer::InferFailReason,
         infer_expr, LuaInferCache,
     },
-    LuaFunctionType, TypeVisitTrait,
+    GenericTpl, GenericTplId, LuaFunctionType, LuaGenericType, TypeVisitTrait,
 };
 
 use super::{instantiate_type_generic::instantiate_doc_function, TypeSubstitutor};
@@ -58,14 +58,15 @@ pub fn instantiate_func_generic(
         .get_args()
         .collect::<Vec<_>>();
     let mut substitutor = TypeSubstitutor::new();
+    let mut context = TplContext {
+        db,
+        cache,
+        substitutor: &mut substitutor,
+        root: call_expr.get_root(),
+        call_expr: Some(call_expr.clone()),
+    };
     if !generic_tpls.is_empty() {
-        substitutor.add_need_infer_tpls(generic_tpls);
-        let mut context = TplContext {
-            db,
-            cache,
-            substitutor: &mut substitutor,
-            root: call_expr.get_root(),
-        };
+        context.substitutor.add_need_infer_tpls(generic_tpls);
 
         let colon_call = call_expr.is_colon_call();
         let colon_define = func.is_colon_define();
@@ -141,9 +142,10 @@ pub fn instantiate_func_generic(
         }
     }
 
-    substitutor.set_call_expr(call_expr.clone());
     if contain_self {
-        infer_self_type(db, cache, &call_expr, &mut substitutor)?;
+        if 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) {
@@ -153,7 +155,31 @@ pub fn instantiate_func_generic(
     }
 }
 
-fn infer_self_type(
+pub fn build_self_type(db: &DbIndex, self_type: &LuaType) -> LuaType {
+    match self_type {
+        LuaType::Def(id) | LuaType::Ref(id) => {
+            if let Some(generic) = db.get_type_index().get_generic_params(id) {
+                let mut params = Vec::new();
+                for (i, ty) in generic.iter().enumerate() {
+                    if let Some(t) = &ty.1 {
+                        params.push(t.clone());
+                    } else {
+                        params.push(LuaType::TplRef(Arc::new(GenericTpl::new(
+                            GenericTplId::Type(i as u32),
+                            ArcIntern::new(SmolStr::from(ty.0.clone())),
+                        ))));
+                    }
+                }
+                let generic = LuaGenericType::new(id.clone(), params);
+                return LuaType::Generic(Arc::new(generic));
+            }
+        }
+        _ => {}
+    };
+    self_type.clone()
+}
+
+pub fn infer_self_type(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     call_expr: &LuaCallExpr,

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

@@ -1,4 +1,4 @@
-use emmylua_parser::LuaSyntaxNode;
+use emmylua_parser::{LuaCallExpr, LuaSyntaxNode};
 
 use crate::{DbIndex, LuaInferCache, TypeSubstitutor};
 
@@ -8,4 +8,5 @@ pub struct TplContext<'a> {
     pub cache: &'a mut LuaInferCache,
     pub substitutor: &'a mut TypeSubstitutor,
     pub root: LuaSyntaxNode,
+    pub call_expr: Option<LuaCallExpr>,
 }

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

@@ -12,6 +12,7 @@ use crate::{
     semantic::{
         generic::{tpl_context::TplContext, type_substitutor::SubstitutorValue},
         member::{find_index_operations, get_member_map},
+        type_check::is_sub_type_of,
     },
     InferFailReason, LuaFunctionType, LuaMemberInfo, LuaMemberKey, LuaMemberOwner, LuaObjectType,
     LuaSemanticDeclId, LuaTupleType, LuaUnionType, SemanticDeclLevel, VariadicType,
@@ -480,9 +481,10 @@ fn generic_tpl_pattern_match(
 ) -> TplPatternMatchResult {
     match target {
         LuaType::Generic(target_generic) => {
-            let base = generic.get_base_type();
-            let target_base = target_generic.get_base_type();
-            if target_base != base {
+            let base = generic.get_base_type_id_ref();
+            let target_base = target_generic.get_base_type_id_ref();
+
+            if !is_sub_type_of(context.db, &target_base, &base) {
                 return Err(InferFailReason::None);
             }
 
@@ -872,7 +874,7 @@ fn escape_alias(db: &DbIndex, may_alias: &LuaType) -> LuaType {
 }
 
 fn is_pairs_call(context: &mut TplContext) -> Option<bool> {
-    let call_expr = context.substitutor.get_call_expr()?;
+    let call_expr = context.call_expr.as_ref()?;
     let prefix_expr = call_expr.get_prefix_expr()?;
     let semantic_decl = match prefix_expr.syntax().clone().into() {
         NodeOrToken::Node(node) => infer_node_semantic_decl(

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

@@ -1,15 +1,12 @@
 use std::collections::{HashMap, HashSet};
 
-use emmylua_parser::LuaCallExpr;
-
 use crate::{GenericTplId, LuaType, LuaTypeDeclId};
 
 #[derive(Debug, Clone)]
 pub struct TypeSubstitutor {
     tpl_replace_map: HashMap<GenericTplId, SubstitutorValue>,
     alias_type_id: Option<LuaTypeDeclId>,
     self_type: Option<LuaType>,
-    call_expr: Option<LuaCallExpr>,
 }
 
 impl TypeSubstitutor {
@@ -18,7 +15,6 @@ impl TypeSubstitutor {
             tpl_replace_map: HashMap::new(),
             alias_type_id: None,
             self_type: None,
-            call_expr: None,
         }
     }
 
@@ -31,7 +27,6 @@ impl TypeSubstitutor {
             tpl_replace_map,
             alias_type_id: None,
             self_type: None,
-            call_expr: None,
         }
     }
 
@@ -44,7 +39,6 @@ impl TypeSubstitutor {
             tpl_replace_map,
             alias_type_id: Some(alias_type_id),
             self_type: None,
-            call_expr: None,
         }
     }
 
@@ -148,14 +142,6 @@ impl TypeSubstitutor {
             }
         }
     }
-
-    pub fn set_call_expr(&mut self, call_expr: LuaCallExpr) {
-        self.call_expr = Some(call_expr);
-    }
-
-    pub fn get_call_expr(&self) -> Option<&LuaCallExpr> {
-        self.call_expr.as_ref()
-    }
 }
 
 fn convert_type_def_to_ref(ty: &LuaType) -> LuaType {

crates/emmylua_code_analysis/src/semantic/type_check/sub_type.rs

@@ -2,6 +2,9 @@ use std::collections::HashSet;
 
 use crate::{DbIndex, LuaType, LuaTypeDeclId};
 
+/// 检查子类型关系.
+///
+/// 假设现在有一个类型定义`---@class C: A, B`, 那么`sub_type_ref_id`为`C`, `super_type_ref_id`可以为`A`或`B`.
 pub fn is_sub_type_of(
     db: &DbIndex,
     sub_type_ref_id: &LuaTypeDeclId,