fix(semantic): reuse branch-narrowed types in expression inference

Flow narrowing sometimes has to evaluate another expression that uses a
value narrowed earlier in the same branch. For example, after `key =
"foo"`, `t[key]` should be checked with `key` as `"foo"`, not with its
declared `"foo"|"bar"` type.

The old fallback avoided recursive flow analysis by evaluating those
expressions without flow. That kept the engine from re-entering itself,
but it also lost precision in assignment RHS expressions, equality
checks, field guards, dynamic table keys, and guarded call or callee
aliases.

This keeps the flow engine responsible for the ordering. It records work
that depends on another expression, resolves the branch-local values
first, then resumes the original expression with those values layered
over the normal no-flow inputs. Static caches and declared/member types
still apply, but temporary expression and call results do not leak into
the normal no-flow caches. Values that cannot be evaluated safely
without flow now return no answer instead of caching broad guesses.

Assignments are conservative. The RHS can still use branch-local values,
but the previous branch-narrowed source for the assignment target is
reused only when the new RHS is compatible with it. Otherwise the engine
falls back to the type before the current guard so stale branch
narrowing is dropped after overwrites.

The indexing changes share lookup data between normal index/table-field
lookup and `__index` fallback. Exact literal keys stay exact, broader
union/keyof/enum key types can expand to matching members, and broad
string or number keys still include nil when they may miss. Lookup paths
used for narrowing still avoid `__index`/operator fallback, so guards
only narrow through members that are present directly.

The call changes apply the same conservative rule to guarded calls and
callee aliases such as `rawget` and `pcall`. Non-string `require` paths
and `setmetatable` calls without real `__index`/custom metatable shapes
now decline in no-flow instead of guessing. Non-generic overloads keep
candidates alive when an argument cannot be evaluated without flow, but
such an argument cannot make an overload win unless the remaining
candidates return the same type.

Regression tests cover branch-narrowed dynamic keys in assignments,
initializers, comparisons, field truthiness, literal equality, stacked
guards, call/callee aliases, member lookup, `pcall`, and ambiguous
overload arguments. Existing assignment overwrite guardrails continue to
cover stale narrowing after overwrite.

Assisted-by: Codex

Author: lewis6991

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

@@ -390,6 +390,28 @@ mod test {
         assert_eq!(ws.expr_ty("result"), LuaType::Integer);
     }
 
+    #[test]
+    fn test_rawget_alias_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 = {}
+        local get = rawget
+
+        if get(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();

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

@@ -176,6 +176,31 @@ mod test {
         assert_eq!(ws.expr_ty("narrowed"), ws.ty("integer"));
     }
 
+    #[test]
+    fn test_pcall_alias_callee_narrows_return_after_error_guard() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        ws.def(
+            r#"
+        ---@return integer
+        local function foo()
+            return 1
+        end
+
+        local runner = pcall
+        local ok, result = runner(foo)
+
+        if not ok then
+            error(result)
+        end
+
+        narrowed = result
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("narrowed"), ws.ty("integer"));
+    }
+
     #[test]
     fn test_pcall_any_callable_splits_success_unknown_and_failure_string() {
         let mut ws = VirtualWorkspace::new_with_init_std_lib();

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

@@ -6,7 +6,10 @@ use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
 
 use super::lua_member_feature::LuaMemberFeature;
-use crate::{DbIndex, FileId, GlobalId, InferFailReason, LuaInferCache, LuaType, infer_expr};
+use crate::{
+    DbIndex, FileId, GlobalId, InferFailReason, LuaInferCache, LuaType,
+    semantic::try_infer_expr_for_index,
+};
 
 #[derive(Debug)]
 pub struct LuaMember {
@@ -116,7 +119,9 @@ impl LuaMemberKey {
             }
             LuaIndexKey::Idx(idx) => Ok(LuaMemberKey::Integer(*idx as i64)),
             LuaIndexKey::Expr(expr) => {
-                let expr_type = infer_expr(db, cache, expr.clone())?;
+                let Some(expr_type) = try_infer_expr_for_index(db, cache, expr.clone())? else {
+                    return Err(InferFailReason::None);
+                };
                 match expr_type {
                     LuaType::StringConst(s) => Ok(LuaMemberKey::Name(s.deref().clone())),
                     LuaType::DocStringConst(s) => Ok(LuaMemberKey::Name(s.deref().clone())),

crates/emmylua_code_analysis/src/db_index/member/lua_member.rs

@@ -3,7 +3,7 @@ mod cache_options;
 pub use cache_options::{CacheOptions, LuaAnalysisPhase};
 use emmylua_parser::{LuaExpr, LuaSyntaxId, LuaVarExpr};
 use hashbrown::{HashMap, HashSet};
-use std::{rc::Rc, sync::Arc};
+use std::{mem, rc::Rc, sync::Arc};
 
 use crate::{
     FileId, FlowId, LuaFunctionType,
@@ -17,13 +17,6 @@ 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>,
@@ -53,15 +46,20 @@ pub(in crate::semantic) struct FlowVarCache {
 pub struct LuaInferCache {
     file_id: FileId,
     config: CacheOptions,
+    no_flow_mode: bool,
     pub expr_cache: HashMap<LuaSyntaxId, CacheEntry<LuaType>>,
+    pub(in crate::semantic) expr_no_flow_cache: HashMap<LuaSyntaxId, CacheEntry<Option<LuaType>>>,
     pub call_cache:
         HashMap<(LuaSyntaxId, Option<usize>, LuaType), CacheEntry<Arc<LuaFunctionType>>>,
+    pub(in crate::semantic) call_no_flow_cache:
+        HashMap<(LuaSyntaxId, Option<usize>, LuaType), CacheEntry<Option<Arc<LuaFunctionType>>>>,
+    replay_expr_types: Vec<(LuaSyntaxId, LuaType)>,
     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<Rc<FlowConditionInfo>>>,
     pub(in crate::semantic) flow_assignment_info_cache: Vec<Option<Rc<FlowAssignmentInfo>>>,
+    pub(in crate::semantic) no_flow_table_exprs: HashSet<LuaSyntaxId>,
     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>,
@@ -72,14 +70,18 @@ impl LuaInferCache {
         Self {
             file_id,
             config,
+            no_flow_mode: false,
             expr_cache: HashMap::new(),
+            expr_no_flow_cache: HashMap::new(),
             call_cache: HashMap::new(),
+            call_no_flow_cache: HashMap::new(),
+            replay_expr_types: Vec::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(),
+            no_flow_table_exprs: HashSet::new(),
             index_ref_origin_type_cache: HashMap::new(),
             expr_var_ref_id_cache: HashMap::new(),
             narrow_by_literal_stop_position_cache: HashSet::new(),
@@ -94,20 +96,80 @@ impl LuaInferCache {
         self.file_id
     }
 
+    pub(in crate::semantic) fn is_no_flow(&self) -> bool {
+        self.no_flow_mode
+    }
+
+    pub(in crate::semantic) fn with_no_flow<R>(
+        &mut self,
+        f: impl FnOnce(&mut LuaInferCache) -> R,
+    ) -> R {
+        let previous_mode = mem::replace(&mut self.no_flow_mode, true);
+        let result = f(self);
+        self.no_flow_mode = previous_mode;
+        result
+    }
+
+    pub(in crate::semantic) fn replay_expr_type(&self, syntax_id: LuaSyntaxId) -> Option<&LuaType> {
+        self.replay_expr_types
+            .iter()
+            .rev()
+            .find_map(|(overlay_id, ty)| (*overlay_id == syntax_id).then_some(ty))
+    }
+
+    pub(in crate::semantic) fn with_replay_overlay<R>(
+        &mut self,
+        expr_types: &[(LuaSyntaxId, LuaType)],
+        table_exprs: &[LuaSyntaxId],
+        f: impl FnOnce(&mut LuaInferCache) -> R,
+    ) -> R {
+        if expr_types.is_empty() && table_exprs.is_empty() {
+            return f(self);
+        }
+
+        // Replay overlays change no-flow answers, so isolate overlay-dependent
+        // cache writes from the normal no-flow caches.
+        let overlay_len = self.replay_expr_types.len();
+        self.replay_expr_types.extend(expr_types.iter().cloned());
+        let mut inserted_table_exprs = Vec::new();
+        for syntax_id in table_exprs {
+            if self.no_flow_table_exprs.insert(*syntax_id) {
+                inserted_table_exprs.push(*syntax_id);
+            }
+        }
+        let saved_expr_no_flow_cache = mem::take(&mut self.expr_no_flow_cache);
+        let saved_call_no_flow_cache = mem::take(&mut self.call_no_flow_cache);
+
+        let result = f(self);
+
+        self.expr_no_flow_cache = saved_expr_no_flow_cache;
+        self.call_no_flow_cache = saved_call_no_flow_cache;
+        for syntax_id in inserted_table_exprs {
+            self.no_flow_table_exprs.remove(&syntax_id);
+        }
+        self.replay_expr_types.truncate(overlay_len);
+        result
+    }
+
     pub fn set_phase(&mut self, phase: LuaAnalysisPhase) {
         self.config.analysis_phase = phase;
     }
 
     pub fn clear(&mut self) {
+        self.no_flow_mode = false;
         self.expr_cache.clear();
+        self.expr_no_flow_cache.clear();
         self.call_cache.clear();
+        self.call_no_flow_cache.clear();
+        self.replay_expr_types.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.no_flow_table_exprs.clear();
         self.index_ref_origin_type_cache.clear();
         self.expr_var_ref_id_cache.clear();
+        self.narrow_by_literal_stop_position_cache.clear();
     }
 }

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

@@ -5,7 +5,7 @@ use crate::{
     semantic::infer::InferResult,
 };
 
-pub fn infer_require_call(
+pub(super) fn infer_require_call(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     call_expr: LuaCallExpr,
@@ -14,7 +14,12 @@ pub fn infer_require_call(
     let first_arg = arg_list.get_args().next().ok_or(InferFailReason::None)?;
     let require_path_type = infer_expr(db, cache, first_arg)?;
     let module_path: String = match &require_path_type {
-        LuaType::StringConst(module_path) => module_path.as_ref().to_string(),
+        LuaType::StringConst(module_path) | LuaType::DocStringConst(module_path) => {
+            module_path.as_ref().to_string()
+        }
+        _ if cache.is_no_flow() => {
+            return Err(InferFailReason::None);
+        }
         _ => {
             return Ok(LuaType::Any);
         }

crates/emmylua_code_analysis/src/semantic/infer/infer_call/infer_require.rs

@@ -6,7 +6,7 @@ use crate::{
     semantic::{infer::InferResult, member::find_members_with_key},
 };
 
-pub fn infer_setmetatable_call(
+pub(super) fn infer_setmetatable_call(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     call_expr: LuaCallExpr,
@@ -22,6 +22,12 @@ pub fn infer_setmetatable_call(
     let metatable = args[1].clone();
 
     let (meta_type, is_index) = infer_metatable_index_type(db, cache, metatable)?;
+    if cache.is_no_flow() && !is_index && !meta_type.is_custom_type() {
+        // No-flow setmetatable inference is only used as a conservative fallback.
+        // If the metatable does not resolve to an actual metatable shape, decline
+        // instead of treating arbitrary static expressions as the result type.
+        return Err(InferFailReason::None);
+    }
     match &basic_table {
         LuaExpr::TableExpr(table_expr) => {
             if table_expr.is_empty() && is_index {

crates/emmylua_code_analysis/src/semantic/infer/infer_call/infer_setmetatable.rs

@@ -38,18 +38,31 @@ pub fn infer_call_expr_func(
 ) -> InferCallFuncResult {
     let syntax_id = call_expr.get_syntax_id();
     let key = (syntax_id, args_count, call_expr_type.clone());
-    if let Some(cache) = cache.call_cache.get(&key) {
-        match cache {
+    let is_no_flow = cache.is_no_flow();
+    if is_no_flow {
+        if let Some(cache_entry) = cache.call_no_flow_cache.get(&key) {
+            match cache_entry {
+                CacheEntry::Cache(Some(ty)) => return Ok(ty.clone()),
+                CacheEntry::Cache(None) => return Err(InferFailReason::None),
+                CacheEntry::Ready => return Err(InferFailReason::RecursiveInfer),
+            }
+        }
+    } else if let Some(cache_entry) = cache.call_cache.get(&key) {
+        match cache_entry {
             CacheEntry::Cache(ty) => return Ok(ty.clone()),
-            _ => return Err(InferFailReason::RecursiveInfer),
+            CacheEntry::Ready => return Err(InferFailReason::RecursiveInfer),
         }
     }
 
-    cache.call_cache.insert(key.clone(), CacheEntry::Ready);
+    if is_no_flow {
+        cache
+            .call_no_flow_cache
+            .insert(key.clone(), CacheEntry::Ready);
+    } else {
+        cache.call_cache.insert(key.clone(), CacheEntry::Ready);
+    }
     let result = match &call_expr_type {
-        LuaType::DocFunction(func) => {
-            infer_doc_function(db, cache, func, call_expr.clone(), args_count)
-        }
+        LuaType::DocFunction(func) => infer_doc_function(db, cache, func, call_expr.clone()),
         LuaType::Signature(signature_id) => {
             infer_signature_doc_function(db, cache, *signature_id, call_expr.clone(), args_count)
         }
@@ -143,15 +156,34 @@ pub fn infer_call_expr_func(
 
     match &result {
         Ok(func_ty) => {
+            if is_no_flow {
+                cache
+                    .call_no_flow_cache
+                    .insert(key, CacheEntry::Cache(Some(func_ty.clone())));
+            } else {
+                cache
+                    .call_cache
+                    .insert(key, CacheEntry::Cache(func_ty.clone()));
+            }
+        }
+        Err(InferFailReason::None) | Err(InferFailReason::RecursiveInfer) if is_no_flow => {
             cache
-                .call_cache
-                .insert(key, CacheEntry::Cache(func_ty.clone()));
+                .call_no_flow_cache
+                .insert(key, CacheEntry::Cache(None));
         }
         Err(r) if r.is_need_resolve() => {
-            cache.call_cache.remove(&key);
+            if is_no_flow {
+                cache.call_no_flow_cache.remove(&key);
+            } else {
+                cache.call_cache.remove(&key);
+            }
         }
         Err(InferFailReason::None) => {
-            cache.call_cache.remove(&key);
+            if is_no_flow {
+                cache.call_no_flow_cache.remove(&key);
+            } else {
+                cache.call_cache.remove(&key);
+            }
         }
         _ => {}
     }
@@ -181,7 +213,6 @@ fn infer_doc_function(
     cache: &mut LuaInferCache,
     func: &LuaFunctionType,
     call_expr: LuaCallExpr,
-    _: Option<usize>,
 ) -> InferCallFuncResult {
     if func.contain_tpl() {
         let result = instantiate_func_generic(db, cache, func, call_expr)?;
@@ -597,7 +628,7 @@ fn infer_intersection(
     resolve_signature(db, cache, overloads, call_expr, false, args_count)
 }
 
-pub(crate) fn unwrapp_return_type(
+fn unwrapp_return_type(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     return_type: LuaType,
@@ -721,7 +752,8 @@ pub fn infer_call_expr(
     .get_ret()
     .clone();
 
-    if let Some(tree) = db.get_flow_index().get_flow_tree(&cache.get_file_id())
+    if !cache.is_no_flow()
+        && let Some(tree) = db.get_flow_index().get_flow_tree(&cache.get_file_id())
         && let Some(flow_id) = tree.get_flow_id(call_expr.get_syntax_id())
         && let Some(flow_ret_type) =
             get_type_at_call_expr_inline_cast(db, cache, tree, call_expr, flow_id, ret_type.clone())