Support for generic matching table

Author: xuhuanzy

crates/emmylua_code_analysis/src/diagnostic/test/param_type_check_test.rs

@@ -1134,4 +1134,37 @@ mod test {
             "#
         ));
     }
+
+    #[test]
+    fn test_generic_type() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+                ---@class ObserverParams<T>
+                ---@field next fun( value: T)
+                ---@field errorResume? fun(error: any)
+
+
+                ---@class Observer<T>
+                local Observer = {}
+
+                ---@param observer ObserverParams<T>
+                function Observer:subscribe(observer)
+                end
+        "#,
+        );
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeNotMatch,
+            r#"
+            ---@type Observer<number>
+            local observer
+
+            observer:subscribe({
+                next = function(value)
+                    print(value)
+                end
+            })
+            "#
+        ));
+    }
 }

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

@@ -1,4 +1,9 @@
-use crate::{DbIndex, LuaGenericType, LuaType, TypeSubstitutor};
+use std::{collections::HashMap, sync::Arc};
+
+use crate::{
+    humanize_type, semantic::member::find_members, DbIndex, LuaGenericType, LuaMemberOwner,
+    LuaType, LuaTypeCache, RenderLevel, TypeSubstitutor,
+};
 
 use super::{
     check_general_type_compact, type_check_fail_reason::TypeCheckFailReason,
@@ -11,7 +16,7 @@ pub fn check_generic_type_compact(
     compact_type: &LuaType,
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
-    // Do not check generic classes that have not been instantiated yet
+    // 不检查尚未实例化的泛型类
     if source_generic.contain_tpl() {
         return Ok(());
     }
@@ -22,9 +27,8 @@ pub fn check_generic_type_compact(
         .get_type_decl(&source_base_id)
         .ok_or(TypeCheckFailReason::TypeNotMatch)?;
 
-    let type_params = source_generic.get_params();
-
     if type_decl.is_alias() {
+        let type_params = source_generic.get_params();
         let substitutor = TypeSubstitutor::from_alias(type_params.clone(), source_base_id);
         if let Some(origin_type) = type_decl.get_alias_origin(db, Some(&substitutor)) {
             return check_general_type_compact(
@@ -37,17 +41,19 @@ pub fn check_generic_type_compact(
     }
 
     match compact_type {
-        LuaType::Generic(compact_generic) => {
-            return check_generic_type_compact_generic(
-                db,
-                source_generic,
-                compact_generic,
-                check_guard.next_level()?,
-            )
-        }
-        _ => {
-            return Err(TypeCheckFailReason::TypeNotMatch);
-        }
+        LuaType::Generic(compact_generic) => check_generic_type_compact_generic(
+            db,
+            source_generic,
+            compact_generic,
+            check_guard.next_level()?,
+        ),
+        LuaType::TableConst(range) => check_generic_type_compact_table(
+            db,
+            source_generic,
+            LuaMemberOwner::Element(range.clone()),
+            check_guard.next_level()?,
+        ),
+        _ => Err(TypeCheckFailReason::TypeNotMatch),
     }
 }
 
@@ -69,10 +75,94 @@ fn check_generic_type_compact_generic(
         return Err(TypeCheckFailReason::TypeNotMatch);
     }
 
-    for i in 0..source_params.len() {
-        let source_param = &source_params[i];
-        let compact_param = &compact_params[i];
-        check_general_type_compact(db, source_param, compact_param, check_guard.next_level()?)?;
+    let next_guard = check_guard.next_level()?;
+    for (source_param, compact_param) in source_params.iter().zip(compact_params.iter()) {
+        check_general_type_compact(db, source_param, compact_param, next_guard)?;
+    }
+
+    Ok(())
+}
+
+fn check_generic_type_compact_table(
+    db: &DbIndex,
+    source_generic: &LuaGenericType,
+    table_owner: LuaMemberOwner,
+    check_guard: TypeCheckGuard,
+) -> TypeCheckResult {
+    let member_index = db.get_member_index();
+
+    // 构建表成员映射
+    let table_member_map: HashMap<_, _> = member_index
+        .get_members(&table_owner)
+        .map(|members| {
+            members
+                .iter()
+                .map(|m| (m.get_key().clone(), m.get_id().clone()))
+                .collect()
+        })
+        .unwrap_or_default();
+
+    // 获取泛型类型的成员，使用 find_members 来获取包括继承的所有成员
+    let source_type = LuaType::Generic(Arc::new(source_generic.clone()));
+    let Some(source_type_members) = find_members(db, &source_type) else {
+        return Ok(()); // 空成员无需检查
+    };
+
+    // 提前计算下一级检查守卫
+    let next_guard = check_guard.next_level()?;
+
+    for source_member in source_type_members {
+        let source_member_type = source_member.typ;
+        let key = source_member.key;
+
+        match table_member_map.get(&key) {
+            Some(table_member_id) => {
+                let table_member = member_index
+                    .get_member(table_member_id)
+                    .ok_or(TypeCheckFailReason::TypeNotMatch)?;
+                let table_member_type = db
+                    .get_type_index()
+                    .get_type_cache(&table_member.get_id().into())
+                    .unwrap_or(&LuaTypeCache::InferType(LuaType::Any))
+                    .as_type();
+
+                if let Err(TypeCheckFailReason::TypeNotMatch) = check_general_type_compact(
+                    db,
+                    &source_member_type,
+                    &table_member_type,
+                    next_guard,
+                ) {
+                    return Err(TypeCheckFailReason::TypeNotMatchWithReason(
+                        t!(
+                            "member %{name} type not match, expect %{expect}, got %{got}",
+                            name = key.to_path(),
+                            expect = humanize_type(db, &source_member_type, RenderLevel::Simple),
+                            got = humanize_type(db, &table_member_type, RenderLevel::Simple)
+                        )
+                        .to_string(),
+                    ));
+                }
+            }
+            None if !source_member_type.is_optional() => {
+                return Err(TypeCheckFailReason::TypeNotMatchWithReason(
+                    t!("missing member %{name}, in table", name = key.to_path()).to_string(),
+                ));
+            }
+            _ => {} // 可选成员未找到，继续检查
+        }
+    }
+
+    // 检查超类型
+    let source_base_id = source_generic.get_base_type_id();
+    if let Some(supers) = db.get_type_index().get_super_types(&source_base_id) {
+        let element_range = table_owner
+            .get_element_range()
+            .ok_or(TypeCheckFailReason::TypeNotMatch)?;
+        let table_type = LuaType::TableConst(element_range.clone());
+
+        for super_type in supers {
+            check_general_type_compact(db, &super_type, &table_type, next_guard)?;
+        }
     }
 
     Ok(())