fix: call type

fix #1164

Author: xuhuanzy

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

@@ -1584,4 +1584,22 @@ return t
         "#
         ));
     }
+
+    #[test]
+    fn test_keyof_nested_doc_index_access_accepts_member_name() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.has_no_diagnostic(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+            ---@class A
+            ---@field test number
+
+            ---@class B
+            ---@field test A
+
+            ---@type keyof B["test"]
+            local tmp = "test"
+            "#
+        ));
+    }
 }

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

@@ -1046,4 +1046,49 @@ mod test {
             "#
         ));
     }
+
+    #[test]
+    fn test_doc_index_access_type_resolves_object_field() {
+        let mut ws = VirtualWorkspace::new();
+        let code = r#"
+            ---@class A
+            ---@field b { test: number }
+
+            ---@type A['b']
+            local tmp
+            local out = tmp.test
+            result = out
+            "#;
+
+        let has_no_diagnostic = ws.has_no_diagnostic(DiagnosticCode::UndefinedField, code);
+        let result_ty = ws.expr_ty("result");
+        let expected_ty = ws.ty("number");
+        let result_type_text = ws.humanize_type(result_ty.clone());
+
+        assert!(
+            has_no_diagnostic && result_ty == expected_ty,
+            "undefined-field diagnostic: {}; result type: {}",
+            !has_no_diagnostic,
+            result_type_text
+        );
+    }
+
+    #[test]
+    fn test_doc_index_access_type_cycle_does_not_overflow() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.has_no_diagnostic(
+            DiagnosticCode::UndefinedField,
+            r#"
+            ---@class A
+            ---@field b B['c']
+
+            ---@class B
+            ---@field c A['b']
+
+            ---@type A['b']
+            local tmp
+            local out = tmp.test
+            "#
+        ));
+    }
 }

crates/emmylua_code_analysis/src/semantic/guard.rs

@@ -1,14 +1,14 @@
 use std::{cell::RefCell, collections::HashSet, rc::Rc};
 
-use crate::{InferFailReason, LuaTypeDeclId};
+use crate::{InferFailReason, LuaType, LuaTypeDeclId};
 
 pub type InferGuardRef = Rc<InferGuard>;
 
 /// Guard to prevent infinite recursion with optimized lazy allocation
 ///
 /// This guard uses a lazy allocation strategy:
 /// - Fork is zero-cost (no HashSet allocation)
-/// - `current` HashSet is only created when needed (write-on-create)
+/// - Visited declaration and instantiated type sets are only created when needed
 /// - Most child guards never allocate memory if they only read from parents
 ///
 /// # Memory Layout
@@ -23,9 +23,10 @@ pub type InferGuardRef = Rc<InferGuard>;
 /// ```
 #[derive(Debug, Clone)]
 pub struct InferGuard {
-    /// Current level's visited types (lazily allocated)
-    /// Only created when we need to add a new type not in parent chain
+    /// Current level's visited type declarations (lazily allocated)
     current: RefCell<Option<HashSet<LuaTypeDeclId>>>,
+    /// Current level's visited instantiated types (lazily allocated)
+    current_types: RefCell<Option<HashSet<LuaType>>>,
     /// Parent guard (shared reference)
     parent: Option<Rc<InferGuard>>,
 }
@@ -34,6 +35,7 @@ impl InferGuard {
     pub fn new() -> Rc<Self> {
         Rc::new(Self {
             current: RefCell::new(None),
+            current_types: RefCell::new(None),
             parent: None,
         })
     }
@@ -44,6 +46,7 @@ impl InferGuard {
     pub fn fork(self: &Rc<Self>) -> Rc<Self> {
         Rc::new(Self {
             current: RefCell::new(None), // Lazy allocation
+            current_types: RefCell::new(None),
             parent: Some(Rc::clone(self)),
         })
     }
@@ -70,6 +73,20 @@ impl InferGuard {
         Ok(())
     }
 
+    pub fn check_type(&self, typ: &LuaType) -> Result<(), InferFailReason> {
+        if self.contains_type_in_parents(typ) {
+            return Err(InferFailReason::RecursiveInfer);
+        }
+
+        let mut current_types = self.current_types.borrow_mut();
+        let current_types = current_types.get_or_insert_with(HashSet::default);
+        if !current_types.insert(typ.clone()) {
+            return Err(InferFailReason::RecursiveInfer);
+        }
+
+        Ok(())
+    }
+
     /// Check if a type has been visited in parent chain
     fn contains_in_parents(&self, type_id: &LuaTypeDeclId) -> bool {
         let mut current_parent = self.parent.as_ref();
@@ -84,6 +101,19 @@ impl InferGuard {
         false
     }
 
+    fn contains_type_in_parents(&self, typ: &LuaType) -> bool {
+        let mut current_parent = self.parent.as_ref();
+        while let Some(parent) = current_parent {
+            if let Some(ref types) = *parent.current_types.borrow()
+                && types.contains(typ)
+            {
+                return true;
+            }
+            current_parent = parent.parent.as_ref();
+        }
+        false
+    }
+
     /// Check if a type has been visited (without modifying the guard)
     pub fn contains(&self, type_id: &LuaTypeDeclId) -> bool {
         // Check current level
@@ -99,6 +129,11 @@ impl InferGuard {
     /// Get the depth of current level
     pub fn current_depth(&self) -> usize {
         self.current.borrow().as_ref().map_or(0, |set| set.len())
+            + self
+                .current_types
+                .borrow()
+                .as_ref()
+                .map_or(0, |set| set.len())
     }
 
     /// Get the total depth of the entire guard chain
@@ -127,7 +162,7 @@ impl InferGuard {
     /// Useful for debugging and performance analysis
     #[cfg(test)]
     pub fn has_allocated(&self) -> bool {
-        self.current.borrow().is_some()
+        self.current.borrow().is_some() || self.current_types.borrow().is_some()
     }
 }
 

crates/emmylua_code_analysis/src/semantic/infer/infer_index/mod.rs

@@ -336,6 +336,19 @@ fn infer_member_by_lookup(
         LuaType::TableGeneric(table_generic) => {
             infer_table_generic_member_by_key_type(db, table_generic, &lookup.key_type)
         }
+        LuaType::Call(alias_call)
+            if alias_call.get_call_kind() == LuaAliasCallKind::Index
+                && !prefix_type.contain_tpl() =>
+        {
+            let index_guard = infer_guard.fork();
+            index_guard.check_type(prefix_type)?;
+            let resolved = instantiate_type_generic(db, prefix_type, &TypeSubstitutor::new());
+            if resolved == *prefix_type {
+                Err(InferFailReason::FieldNotFound)
+            } else {
+                infer_member_by_lookup(db, cache, &resolved, lookup, &index_guard)
+            }
+        }
         LuaType::TplRef(tpl) => infer_tpl_ref_member(db, cache, tpl, lookup, infer_guard),
         LuaType::ModuleRef(file_id) => {
             let module_info = db.get_module_index().get_module(*file_id);

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

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::{
     LuaAliasCallKind, LuaAliasCallType, LuaMemberKey, LuaType, LuaUnionType, TypeCheckFailReason,
-    TypeCheckResult, get_keyof_members,
+    TypeCheckResult, TypeSubstitutor, get_keyof_members, instantiate_type_generic,
     semantic::type_check::{
         check_general_type_compact, type_check_context::TypeCheckContext,
         type_check_guard::TypeCheckGuard,
@@ -69,7 +69,8 @@ pub fn check_call_type_compact(
 }
 
 fn get_keyof_keys(context: &TypeCheckContext, prefix_type: &LuaType) -> Vec<LuaType> {
-    let members = get_keyof_members(context.db, prefix_type).unwrap_or_default();
+    let prefix_type = instantiate_type_generic(context.db, prefix_type, &TypeSubstitutor::new());
+    let members = get_keyof_members(context.db, &prefix_type).unwrap_or_default();
     let key_types = members
         .iter()
         .filter_map(|m| match &m.key {