fix(type-check): resolve indexed access through keyof aliases

Author: xuhuanzy

crates/emmylua_code_analysis/src/db_index/type/humanize_type.rs

@@ -540,27 +540,41 @@ impl<'a> TypeHumanizer<'a> {
         let operands = inner.get_operands();
         let saved = self.level;
         self.level = self.child_level();
-        let result = (|| match inner.get_call_kind() {
+        let result = match inner.get_call_kind() {
             LuaAliasCallKind::KeyOf => {
-                w.write_str("keyof ")?;
+                let mut result = w.write_str("keyof ");
                 for (i, ty) in operands.iter().enumerate() {
-                    if i > 0 {
-                        w.write_char(',')?;
+                    if result.is_ok() && i > 0 {
+                        result = w.write_char(',');
+                    }
+                    if result.is_ok() {
+                        result = self.write_type(ty, w);
                     }
-                    self.write_type(ty, w)?;
                 }
-                Ok(())
+                result
             }
             LuaAliasCallKind::Extends if operands.len() == 2 => {
-                self.write_type(&operands[0], w)?;
-                w.write_str(" extends ")?;
-                self.write_type(&operands[1], w)
+                let mut result = self.write_type(&operands[0], w);
+                if result.is_ok() {
+                    result = w.write_str(" extends ");
+                }
+                if result.is_ok() {
+                    result = self.write_type(&operands[1], w);
+                }
+                result
             }
             LuaAliasCallKind::Index if operands.len() == 2 => {
-                self.write_type(&operands[0], w)?;
-                w.write_char('[')?;
-                self.write_type(&operands[1], w)?;
-                w.write_char(']')
+                let mut result = self.write_type(&operands[0], w);
+                if result.is_ok() {
+                    result = w.write_char('[');
+                }
+                if result.is_ok() {
+                    result = self.write_type(&operands[1], w);
+                }
+                if result.is_ok() {
+                    result = w.write_char(']');
+                }
+                result
             }
             call_kind => {
                 let basic = match call_kind {
@@ -574,17 +588,24 @@ impl<'a> TypeHumanizer<'a> {
                     LuaAliasCallKind::RawGet => "rawget",
                     LuaAliasCallKind::Merge => "Merge",
                 };
-                w.write_str(basic)?;
-                w.write_char('<')?;
+                let mut result = w.write_str(basic);
+                if result.is_ok() {
+                    result = w.write_char('<');
+                }
                 for (i, ty) in operands.iter().enumerate() {
-                    if i > 0 {
-                        w.write_char(',')?;
+                    if result.is_ok() && i > 0 {
+                        result = w.write_char(',');
+                    }
+                    if result.is_ok() {
+                        result = self.write_type(ty, w);
                     }
-                    self.write_type(ty, w)?;
                 }
-                w.write_char('>')
+                if result.is_ok() {
+                    result = w.write_char('>');
+                }
+                result
             }
-        })();
+        };
         self.level = saved;
         result
     }

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

@@ -1537,6 +1537,28 @@ mod test {
         ));
     }
 
+    #[test]
+    fn test_index_access_with_keyof_alias() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.has_no_diagnostic(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            ---@class A
+            ---@field one 1
+
+            ---@alias KeyofA keyof A
+            ---@type A[KeyofA]
+            local tmp
+
+            ---@param v 1
+            local function test(v)
+            end
+
+            test(tmp)
+        "#,
+        ));
+    }
+
     #[test]
     fn test_origin_self() {
         let mut ws = VirtualWorkspace::new();

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

@@ -44,7 +44,9 @@ pub(super) fn instantiate_alias_call(
                 return LuaType::Unknown;
             }
 
-            let members = get_keyof_members(context.db, &operands[0]).unwrap_or_default();
+            let owner = instantiate_alias_origin_operand(context, &operands[0])
+                .unwrap_or_else(|| operands[0].clone());
+            let members = get_keyof_members(context.db, &owner).unwrap_or_default();
             // keyof 表示可取键的联合类型, 不是按位置展开的 tuple.
             let member_key_types = members
                 .iter()
@@ -92,6 +94,7 @@ pub(super) fn instantiate_alias_call(
             }
 
             let key = resolve_literal_operand(operand_exprs.get(1), context.substitutor)
+                .or_else(|| instantiate_alias_origin_operand(context, &operands[1]))
                 .unwrap_or_else(|| operands[1].clone());
 
             instantiate_rawget_call(context.db, &operands[0], &key)
@@ -108,6 +111,7 @@ pub(super) fn instantiate_alias_call(
             }
 
             let key = resolve_literal_operand(operand_exprs.get(1), context.substitutor)
+                .or_else(|| instantiate_alias_origin_operand(context, &operands[1]))
                 .unwrap_or_else(|| operands[1].clone());
 
             instantiate_index_call(context.db, &operands[0], &key)
@@ -116,6 +120,22 @@ pub(super) fn instantiate_alias_call(
     }
 }
 
+fn instantiate_alias_origin_operand(
+    context: &GenericInstantiateContext,
+    operand: &LuaType,
+) -> Option<LuaType> {
+    let LuaType::Ref(type_id) = operand else {
+        return None;
+    };
+    let type_decl = context.db.get_type_index().get_type_decl(type_id)?;
+    if !type_decl.is_alias() {
+        return None;
+    }
+
+    let origin = type_decl.get_alias_origin(context.db, Some(context.substitutor))?;
+    Some(instantiate_type_generic_inner(context, &origin))
+}
+
 fn instantiate_merge_call(db: &DbIndex, operands: &[LuaType]) -> LuaType {
     if operands.len() != 2 {
         return LuaType::Unknown;

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

@@ -21,8 +21,9 @@ pub use type_check_fail_reason::TypeCheckFailReason;
 use type_check_guard::TypeCheckGuard;
 
 use crate::{
-    LuaGenericType, LuaUnionType, TypeSubstitutor,
+    LuaAliasCallKind, LuaGenericType, LuaUnionType, TypeSubstitutor,
     db_index::{DbIndex, LuaType},
+    instantiate_type_generic,
     semantic::type_check::type_check_context::TypeCheckContext,
 };
 pub use sub_type::is_sub_type_of;
@@ -266,6 +267,17 @@ fn escape_type(db: &DbIndex, typ: &LuaType) -> Option<LuaType> {
                 return Some(origin_type.clone());
             }
         }
+        LuaType::Call(alias_call)
+            if matches!(
+                alias_call.get_call_kind(),
+                LuaAliasCallKind::Index | LuaAliasCallKind::RawGet
+            ) && !typ.contain_tpl() =>
+        {
+            let resolved = instantiate_type_generic(db, typ, &TypeSubstitutor::new());
+            if resolved != *typ {
+                return Some(resolved);
+            }
+        }
         // todo donot escape
         LuaType::Instance(inst) => {
             let base = inst.get_base();