super keyof type check

Author: xuhuanzy

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

@@ -1418,4 +1418,40 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_key_of() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@class SuiteHooks
+            ---@field beforeAll string
+            ---@field afterAll string
+
+            ---@param name keyof SuiteHooks
+            function test(name)
+            end
+        "#,
+        );
+        assert!(!ws.check_code_for(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            test("a")
+        "#,
+        ));
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            test("beforeAll")
+        "#,
+        ));
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            ---@type keyof SuiteHooks
+            local name
+            test(name)
+        "#,
+        ));
+    }
 }

crates/emmylua_code_analysis/src/semantic/type_check/complex_type/call_type_check.rs

@@ -0,0 +1,82 @@
+use std::sync::Arc;
+
+use crate::{
+    LuaAliasCallKind, LuaAliasCallType, LuaMemberKey, LuaType, LuaUnionType, TypeCheckFailReason,
+    TypeCheckResult, get_keyof_members,
+    semantic::type_check::{
+        check_general_type_compact, type_check_context::TypeCheckContext,
+        type_check_guard::TypeCheckGuard,
+    },
+};
+
+pub fn check_call_type_compact(
+    context: &mut TypeCheckContext,
+    source_call: &LuaAliasCallType,
+    compact_type: &LuaType,
+    check_guard: TypeCheckGuard,
+) -> TypeCheckResult {
+    if let LuaAliasCallKind::KeyOf = source_call.get_call_kind() {
+        let source_operands = source_call.get_operands().iter().collect::<Vec<_>>();
+        if source_operands.len() != 1 {
+            return Err(TypeCheckFailReason::TypeNotMatch);
+        }
+        match compact_type {
+            LuaType::Call(compact_call) => {
+                if compact_call.get_call_kind() == LuaAliasCallKind::KeyOf {
+                    if compact_call.as_ref() == source_call {
+                        return Ok(());
+                    }
+                    let compact_operands = compact_call.get_operands().iter().collect::<Vec<_>>();
+                    if compact_operands.len() != 1 {
+                        return Err(TypeCheckFailReason::TypeNotMatch);
+                    }
+
+                    let source_key_types = LuaType::Union(Arc::new(LuaUnionType::from_vec(
+                        get_key_of_key_types(context, &source_operands[0]),
+                    )));
+                    let compact_key_types = LuaType::Union(Arc::new(LuaUnionType::from_vec(
+                        get_key_of_key_types(context, &compact_operands[0]),
+                    )));
+                    return check_general_type_compact(
+                        context,
+                        &source_key_types,
+                        &compact_key_types,
+                        check_guard.next_level()?,
+                    );
+                }
+            }
+            _ => {
+                let key_types = get_key_of_key_types(context, &source_operands[0]);
+                for key_type in &key_types {
+                    match check_general_type_compact(
+                        context,
+                        &key_type,
+                        compact_type,
+                        check_guard.next_level()?,
+                    ) {
+                        Ok(_) => return Ok(()),
+                        Err(e) if e.is_type_not_match() => {}
+                        Err(e) => return Err(e),
+                    }
+                }
+                return Err(TypeCheckFailReason::TypeNotMatch);
+            }
+        }
+    }
+
+    // TODO: 实现其他 call 类型的检查
+    Ok(())
+}
+
+fn get_key_of_key_types(context: &TypeCheckContext, prefix_type: &LuaType) -> Vec<LuaType> {
+    let members = get_keyof_members(context.db, prefix_type).unwrap_or_default();
+    let key_types = members
+        .iter()
+        .filter_map(|m| match &m.key {
+            LuaMemberKey::Integer(i) => Some(LuaType::DocIntegerConst(*i)),
+            LuaMemberKey::Name(s) => Some(LuaType::DocStringConst(s.clone().into())),
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+    key_types
+}

crates/emmylua_code_analysis/src/semantic/type_check/complex_type/mod.rs

@@ -1,10 +1,12 @@
 mod array_type_check;
+mod call_type_check;
 mod intersection_type_check;
 mod object_type_check;
 mod table_generic_check;
 mod tuple_type_check;
 
 use array_type_check::check_array_type_compact;
+use call_type_check::check_call_type_compact;
 use intersection_type_check::check_intersection_type_compact;
 use object_type_check::check_object_type_compact;
 use table_generic_check::check_table_generic_type_compact;
@@ -122,6 +124,9 @@ pub fn check_complex_type_compact(
         LuaType::Generic(_) => {
             return Ok(());
         }
+        LuaType::Call(alias_call) => {
+            return check_call_type_compact(context, alias_call, compact_type, check_guard);
+        }
         LuaType::MultiLineUnion(multi_union) => {
             let union = multi_union.to_union();
             return check_complex_type_compact(

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

@@ -137,13 +137,11 @@ fn check_general_type_compact(
         | LuaType::Union(_)
         | LuaType::Intersection(_)
         | LuaType::TableGeneric(_)
+        | LuaType::Call(_)
         | LuaType::MultiLineUnion(_) => {
             check_complex_type_compact(context, &source, &compact_type, check_guard)
         }
 
-        // need think how to do that
-        LuaType::Call(_) => Ok(()),
-
         // generic type
         LuaType::Generic(generic) => {
             check_generic_type_compact(context, generic, &compact_type, check_guard)

crates/emmylua_ls/src/handlers/test/completion_test.rs

@@ -2375,7 +2375,7 @@ mod tests {
     }
 
     #[gtest]
-    fn test_modle_return_signature() -> Result<()> {
+    fn test_module_return_signature() -> Result<()> {
         let mut ws = ProviderVirtualWorkspace::new();
         ws.def_file(
             "test.lua",