fix(generic): treat keyof instantiation as union

Author: xuhuanzy

crates/emmylua_code_analysis/src/diagnostic/checker/generic/call_constraint.rs

@@ -4,8 +4,9 @@ use emmylua_parser::{LuaAstToken, LuaCallExpr};
 use rowan::TextRange;
 
 use crate::{
-    DbIndex, LuaFunctionType, LuaType, LuaTypeNode, SemanticModel, TypeSubstitutor,
-    build_call_generic_substitutor, collect_callable_overload_groups, instantiate_type_generic,
+    DbIndex, LuaAliasCallKind, LuaFunctionType, LuaType, LuaTypeNode, SemanticModel,
+    TypeSubstitutor, build_call_generic_substitutor, collect_callable_overload_groups,
+    instantiate_type_generic,
 };
 
 // 泛型约束上下文
@@ -188,6 +189,16 @@ fn generic_arg_count(
 pub fn normalize_constraint_type(db: &DbIndex, ty: LuaType) -> LuaType {
     match ty {
         LuaType::Tuple(tuple) if tuple.is_infer_resolve() => tuple.collapse_to_union(db),
+        LuaType::Call(alias_call)
+            if alias_call.get_call_kind() == LuaAliasCallKind::KeyOf
+                && !LuaType::Call(alias_call.clone()).contains_tpl_node() =>
+        {
+            let call_type = LuaType::Call(alias_call);
+            normalize_constraint_type(
+                db,
+                instantiate_type_generic(db, &call_type, &TypeSubstitutor::new()),
+            )
+        }
         _ => ty,
     }
 }

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

@@ -247,6 +247,118 @@ mod test {
         ));
     }
 
+    #[test]
+    fn test_alias_keyof_constraint_accepts_keyof_type() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.has_no_diagnostic(
+            DiagnosticCode::GenericConstraintMismatch,
+            r#"
+            ---@class A
+            ---@field one 1
+            ---@field two 2
+            ---@field three 3
+
+            ---@alias C<K extends keyof A> any
+
+            ---@type C<keyof A>
+            local tmp
+            "#,
+        ));
+    }
+
+    #[test]
+    fn test_alias_keyof_constraint_rejects_keyof_type_with_invalid_key() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.has_no_diagnostic(
+            DiagnosticCode::GenericConstraintMismatch,
+            r#"
+            ---@class A
+            ---@field one 1
+            ---@field two 2
+
+            ---@class B
+            ---@field one 1
+            ---@field missing 3
+
+            ---@alias C<K extends keyof A> any
+
+            ---@type C<keyof B>
+            local tmp
+            "#,
+        ));
+    }
+
+    #[test]
+    fn test_alias_keyof_constraint_rejects_invalid_union_for_keyof_type() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.has_no_diagnostic(
+            DiagnosticCode::GenericConstraintMismatch,
+            r#"
+            ---@class A
+            ---@field one 1
+            ---@field two 2
+
+            ---@alias C<K extends keyof A> any
+
+            ---@type C<'one' | 'missing'>
+            local tmp
+            "#,
+        ));
+    }
+
+    #[test]
+    fn test_alias_dependent_keyof_constraint_uses_explicit_type_arg() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.has_no_diagnostic(
+            DiagnosticCode::GenericConstraintMismatch,
+            r#"
+            ---@class Base
+            ---@field common 1
+
+            ---@class Exact: Base
+            ---@field one 1
+            ---@field two 2
+
+            ---@alias PickFrom<T extends Base, K extends keyof T> any
+
+            ---@type PickFrom<Exact, keyof Exact>
+            local tmp
+            "#,
+        ));
+
+        assert!(!ws.has_no_diagnostic(
+            DiagnosticCode::GenericConstraintMismatch,
+            r#"
+            ---@type PickFrom<Exact, 'error'>
+            local tmp
+            "#,
+        ));
+    }
+
+    #[test]
+    fn test_alias_dependent_keyof_constraint_rejects_keyof_other_type() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.has_no_diagnostic(
+            DiagnosticCode::GenericConstraintMismatch,
+            r#"
+            ---@class Base
+            ---@field common 1
+
+            ---@class Exact: Base
+            ---@field one 1
+
+            ---@class Extra: Base
+            ---@field one 1
+            ---@field missing 2
+
+            ---@alias PickFrom<T extends Base, K extends keyof T> any
+
+            ---@type PickFrom<Exact, keyof Extra>
+            local tmp
+            "#,
+        ));
+    }
+
     #[test]
     fn test_alias_keyof_constraint_rejects_union_with_invalid_key() {
         let mut ws = VirtualWorkspace::new();
@@ -345,6 +457,40 @@ mod test {
         ));
     }
 
+    #[test]
+    fn test_dependent_keyof_default_must_satisfy_any_valid_type_arg() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.has_no_diagnostic(
+            DiagnosticCode::GenericConstraintMismatch,
+            r#"
+            ---@class Base
+            ---@field common 1
+
+            ---@class Exact: Base
+            ---@field one 1
+
+            ---@alias PickFrom<T extends Base = Exact, K extends keyof T = keyof Exact> any
+            "#,
+        ));
+    }
+
+    #[test]
+    fn test_dependent_keyof_default_can_reference_same_type_param() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.has_no_diagnostic(
+            DiagnosticCode::GenericConstraintMismatch,
+            r#"
+            ---@class Base
+            ---@field common 1
+
+            ---@class Exact: Base
+            ---@field one 1
+
+            ---@alias PickFrom<T extends Base = Exact, K extends keyof T = keyof T> any
+            "#,
+        ));
+    }
+
     #[test]
     fn test_alias_generic_default_constraint_mismatch() {
         let mut ws = VirtualWorkspace::new();

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

@@ -1,6 +1,6 @@
 use crate::{
     DbIndex, LuaAliasCallKind, LuaAliasCallType, LuaMemberInfo, LuaMemberKey, LuaObjectType,
-    LuaTupleStatus, LuaTupleType, LuaType, LuaTypeNode, TypeOps, VariadicType, get_member_map,
+    LuaType, LuaTypeNode, TypeOps, VariadicType, get_member_map,
     semantic::{
         generic::key_type_to_member_key,
         member::{find_members, infer_raw_member_type},
@@ -45,6 +45,7 @@ pub(super) fn instantiate_alias_call(
             }
 
             let members = get_keyof_members(context.db, &operands[0]).unwrap_or_default();
+            // keyof 表示可取键的联合类型, 不是按位置展开的 tuple.
             let member_key_types = members
                 .iter()
                 .filter_map(|m| match &m.key {
@@ -53,7 +54,7 @@ pub(super) fn instantiate_alias_call(
                     _ => None,
                 })
                 .collect::<Vec<_>>();
-            LuaType::Tuple(LuaTupleType::new(member_key_types, LuaTupleStatus::InferResolve).into())
+            TypeOps::union_all(context.db, member_key_types)
         }
         // 条件类型不在此处理
         LuaAliasCallKind::Extends => {

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

@@ -1,6 +1,8 @@
 #[cfg(test)]
 mod test {
-    use crate::{DiagnosticCode, LuaType, VirtualWorkspace};
+    use crate::{
+        DiagnosticCode, LuaType, RenderLevel, TypeSubstitutor, VirtualWorkspace, humanize_type,
+    };
 
     #[test]
     fn test_variadic_func() {
@@ -272,6 +274,53 @@ result = {
         assert_eq!(a, expected);
     }
 
+    #[test]
+    fn test_keyof_generic_instantiates_to_union() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@class A
+            ---@field one 1
+            ---@field two 2
+            ---@field three 3
+
+            ---@alias B<T> T extends any and keyof T or never
+            "#,
+        );
+
+        let ty = ws.ty("B<A>");
+        let db = ws.analysis.compilation.get_db();
+        let origin = match ty {
+            LuaType::Generic(generic) => {
+                let type_decl = db
+                    .get_type_index()
+                    .get_type_decl(&generic.get_base_type_id())
+                    .expect("B must resolve to an alias declaration");
+                let substitutor = TypeSubstitutor::from_type_array(generic.get_params().clone());
+                type_decl
+                    .get_alias_origin(&db, Some(&substitutor))
+                    .expect("B<A> must expand to its instantiated alias origin")
+            }
+            ty => ty,
+        };
+
+        let LuaType::Union(union) = &origin else {
+            panic!(
+                "keyof generic should instantiate to union, got {}",
+                humanize_type(&db, &origin, RenderLevel::Detailed)
+            );
+        };
+
+        let mut keys = union
+            .into_vec()
+            .iter()
+            .map(|ty| humanize_type(&db, ty, RenderLevel::Brief))
+            .collect::<Vec<_>>();
+        keys.sort();
+
+        assert_eq!(keys, vec!["\"one\"", "\"three\"", "\"two\""]);
+    }
+
     #[test]
     fn test_generic_alias_instantiation2() {
         let mut ws = VirtualWorkspace::new();