fix(semantic): make flow narrowing iterative

Replace recursive flow evaluation with an explicit query stack so deep
branch and condition chains stay stack-safe. Cache per-var flow lookups,
flattened branch inputs, and decoded flow metadata to avoid rebuilding
the same narrowing state on repeated queries, and add focused
regressions around issue #1028, correlated guards, and index-based
narrows.

Fixes #1028

Author: lewis6991

crates/emmylua_code_analysis/src/compilation/test/flow.rs

@@ -1866,6 +1866,27 @@ end
         assert_eq!(b, b_expected);
     }
 
+    #[test]
+    fn test_feature_const_local_alias_chain_does_not_inherit_flow() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(
+            r#"
+            local ret --- @type string | nil
+
+            local is_string = type(ret) == "string"
+            local ok = is_string
+            if ok then
+                a = ret
+            end
+            "#,
+        );
+
+        let a = ws.expr_ty("a");
+        let a_expected = ws.ty("string?");
+        assert_eq!(a, a_expected);
+    }
+
     #[test]
     fn test_feature_generic_type_guard() {
         let mut ws = VirtualWorkspace::new();

crates/emmylua_code_analysis/src/compilation/test/member_infer_test.rs

@@ -368,4 +368,99 @@ mod test {
 
         assert_eq!(ws.expr_ty("result"), ws.ty("never"));
     }
+
+    #[test]
+    fn test_rawget_guard_narrows_matching_index_expr() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(
+            r#"
+        ---@class T
+        ---@field x? integer
+
+        ---@type T
+        local t = {}
+
+        if rawget(t, "x") then
+            result = t.x
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), LuaType::Integer);
+    }
+
+    #[test]
+    fn test_type_guard_call_narrows_matching_index_expr() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+        ---@generic T
+        ---@param inst any
+        ---@param type `T`
+        ---@return TypeGuard<T>
+        local function instance_of(inst, type)
+            return true
+        end
+
+        ---@class T
+        ---@field x? string|integer
+
+        ---@type T
+        local t = {}
+
+        if instance_of(t.x, "string") then
+            result = t.x
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), LuaType::String);
+    }
+
+    #[test]
+    fn test_alias_predicate_guard_narrows_matching_index_expr() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+        ---@class T
+        ---@field x? integer
+
+        ---@type T
+        local t = {}
+
+        local ok = t.x ~= nil
+        if ok then
+            result = t.x
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), LuaType::Integer);
+    }
+
+    #[test]
+    fn test_alias_chain_predicate_guard_keeps_matching_index_expr_wide() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+        ---@class T
+        ---@field x? integer
+
+        ---@type T
+        local t = {}
+
+        local has_x = t.x ~= nil
+        local ok = has_x
+        if ok then
+            result = t.x
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("result"), ws.ty("integer?"));
+    }
 }

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

@@ -1,16 +1,14 @@
 mod cache_options;
 
 pub use cache_options::{CacheOptions, LuaAnalysisPhase};
-use emmylua_parser::LuaSyntaxId;
-use std::{
-    collections::{HashMap, HashSet},
-    sync::Arc,
-};
+use emmylua_parser::{LuaExpr, LuaSyntaxId, LuaVarExpr};
+use hashbrown::{HashMap, HashSet};
+use std::sync::Arc;
 
 use crate::{
     FileId, FlowId, LuaFunctionType,
     db_index::LuaType,
-    semantic::infer::{ConditionFlowAction, VarRefId},
+    semantic::infer::{ConditionFlowAction, InferConditionFlow, VarRefId},
 };
 
 #[derive(Debug)]
@@ -19,16 +17,51 @@ pub enum CacheEntry<T> {
     Cache(T),
 }
 
+#[derive(Debug, Clone)]
+pub(in crate::semantic) struct FlowConditionInfo {
+    pub expr: LuaExpr,
+    pub index_var_ref_id: Option<VarRefId>,
+    pub index_prefix_var_ref_id: Option<VarRefId>,
+}
+
+#[derive(Debug, Clone)]
+pub(in crate::semantic) struct FlowAssignmentInfo {
+    pub vars: Vec<LuaVarExpr>,
+    pub exprs: Vec<LuaExpr>,
+    pub var_ref_ids: Vec<Option<VarRefId>>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(in crate::semantic) enum FlowMode {
+    WithConditions,
+    WithoutConditions,
+}
+
+impl FlowMode {
+    pub fn uses_conditions(self) -> bool {
+        matches!(self, Self::WithConditions)
+    }
+}
+
+#[derive(Debug, Default)]
+pub(in crate::semantic) struct FlowVarCache {
+    pub type_cache: HashMap<(FlowId, FlowMode), CacheEntry<LuaType>>,
+    pub condition_cache: HashMap<(FlowId, InferConditionFlow), CacheEntry<ConditionFlowAction>>,
+}
+
 #[derive(Debug)]
 pub struct LuaInferCache {
     file_id: FileId,
     config: CacheOptions,
     pub expr_cache: HashMap<LuaSyntaxId, CacheEntry<LuaType>>,
     pub call_cache:
         HashMap<(LuaSyntaxId, Option<usize>, LuaType), CacheEntry<Arc<LuaFunctionType>>>,
-    pub(crate) flow_node_cache: HashMap<(VarRefId, FlowId, bool), CacheEntry<LuaType>>,
-    pub(in crate::semantic) condition_flow_cache:
-        HashMap<(VarRefId, FlowId, bool), CacheEntry<ConditionFlowAction>>,
+    pub(in crate::semantic) flow_cache_var_ref_ids: HashMap<VarRefId, u32>,
+    pub(in crate::semantic) next_flow_cache_var_ref_id: u32,
+    pub(in crate::semantic) flow_var_caches: Vec<FlowVarCache>,
+    pub(in crate::semantic) flow_branch_inputs_cache: Vec<Option<Arc<[FlowId]>>>,
+    pub(in crate::semantic) flow_condition_info_cache: Vec<Option<Arc<FlowConditionInfo>>>,
+    pub(in crate::semantic) flow_assignment_info_cache: Vec<Option<Arc<FlowAssignmentInfo>>>,
     pub index_ref_origin_type_cache: HashMap<VarRefId, CacheEntry<LuaType>>,
     pub expr_var_ref_id_cache: HashMap<LuaSyntaxId, VarRefId>,
     pub narrow_by_literal_stop_position_cache: HashSet<LuaSyntaxId>,
@@ -41,8 +74,12 @@ impl LuaInferCache {
             config,
             expr_cache: HashMap::new(),
             call_cache: HashMap::new(),
-            flow_node_cache: HashMap::new(),
-            condition_flow_cache: HashMap::new(),
+            flow_cache_var_ref_ids: HashMap::new(),
+            next_flow_cache_var_ref_id: 0,
+            flow_var_caches: Vec::new(),
+            flow_branch_inputs_cache: Vec::new(),
+            flow_condition_info_cache: Vec::new(),
+            flow_assignment_info_cache: Vec::new(),
             index_ref_origin_type_cache: HashMap::new(),
             expr_var_ref_id_cache: HashMap::new(),
             narrow_by_literal_stop_position_cache: HashSet::new(),
@@ -64,8 +101,12 @@ impl LuaInferCache {
     pub fn clear(&mut self) {
         self.expr_cache.clear();
         self.call_cache.clear();
-        self.flow_node_cache.clear();
-        self.condition_flow_cache.clear();
+        self.flow_cache_var_ref_ids.clear();
+        self.next_flow_cache_var_ref_id = 0;
+        self.flow_var_caches.clear();
+        self.flow_branch_inputs_cache.clear();
+        self.flow_condition_info_cache.clear();
+        self.flow_assignment_info_cache.clear();
         self.index_ref_origin_type_cache.clear();
         self.expr_var_ref_id_cache.clear();
     }

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

@@ -1,10 +1,9 @@
 mod infer_array;
 
-use std::collections::HashSet;
-
 use emmylua_parser::{
     LuaExpr, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr, NumberResult, PathTrait,
 };
+use hashbrown::HashSet;
 use internment::ArcIntern;
 use rowan::TextRange;
 use smol_str::SmolStr;
@@ -107,6 +106,7 @@ fn infer_member_type_pass_flow(
     cache
         .index_ref_origin_type_cache
         .insert(var_ref_id.clone(), CacheEntry::Cache(member_type.clone()));
+
     let result = infer_expr_narrow_type(db, cache, LuaExpr::IndexExpr(index_expr), var_ref_id);
     match &result {
         Err(InferFailReason::None) => Ok(member_type.clone()),

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

@@ -26,8 +26,8 @@ pub use infer_name::{find_self_decl_or_member_id, infer_param};
 use infer_table::infer_table_expr;
 pub use infer_table::{infer_table_field_value_should_be, infer_table_should_be};
 use infer_unary::infer_unary_expr;
-pub(in crate::semantic) use narrow::ConditionFlowAction;
 pub use narrow::VarRefId;
+pub(in crate::semantic) use narrow::{ConditionFlowAction, InferConditionFlow};
 
 use rowan::TextRange;
 use smol_str::SmolStr;