fix: separate unreachable conditions from never types

Truthiness checks for call conditions treated an impossible branch as
`Result(Never)`. That made the queried symbol look like `never` while walking
the branch, so unrelated callable values inside impossible `if`/`else` bodies
could be narrowed to non-callable.

Add an explicit unreachable condition action and handle it by query mode.
Normal point queries continue past an unreachable condition edge so unrelated
symbols keep their declared types. Merge-branch queries finish with `never`, so
unreachable branch predecessors still drop out of the merged type.

Preserve merge-branch mode through assignment, tag-cast, and correlated
condition subqueries. That prevents assignments and casts inside impossible
branches from contributing their statement-local type effects to the final merge.

Rename flow modes around their actual use and keep single-predecessor
branch labels out of merge mode. Add coverage for plain call conditions,
always-false and always-true call-condition branches, and unreachable
assignment/cast merge contributions.

Assisted-by: Codex

Author: lewis6991

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

@@ -304,6 +304,112 @@ mod test {
         assert_eq!(ws.expr_ty("after_guard"), ws.ty("string"));
     }
 
+    #[test]
+    fn test_plain_call_condition_keeps_inner_call_prefix_type() {
+        let mut ws = VirtualWorkspace::new();
+        let code = r#"
+        local function a() end
+        local function b() end
+
+        b()
+        if a() then
+            b()
+            inner = b
+        end
+        "#;
+        ws.def(code);
+
+        let ty = ws.expr_ty("inner");
+        assert!(ty.is_function());
+
+        let mut diag_ws = VirtualWorkspace::new();
+        assert!(diag_ws.has_no_diagnostic(DiagnosticCode::CallNonCallable, code));
+    }
+
+    #[test]
+    fn test_false_call_condition_keeps_inner_unrelated_type() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@return false
+        local function always_false()
+            return false
+        end
+
+        ---@type string
+        local value = "ok"
+        if always_false() then
+            inner = value
+        end
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("inner"), ws.ty("string"));
+    }
+
+    #[test]
+    fn test_true_call_condition_keeps_else_call_prefix_type() {
+        let mut ws = VirtualWorkspace::new();
+        let code = r#"
+        ---@return true
+        local function always_true()
+            return true
+        end
+
+        local function b() end
+        if always_true() then
+        else
+            b()
+        end
+        "#;
+
+        assert!(ws.has_no_diagnostic(DiagnosticCode::CallNonCallable, code));
+    }
+
+    #[test]
+    fn test_false_call_condition_assignment_does_not_contribute_to_merge() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@return false
+        local function always_false()
+            return false
+        end
+
+        local value = "before"
+        if always_false() then
+            value = 1
+        end
+        after = value
+        "#,
+        );
+
+        let after = ws.expr_ty("after");
+        assert_eq!(ws.humanize_type(after), "string");
+    }
+
+    #[test]
+    fn test_false_call_condition_tag_cast_does_not_contribute_to_merge() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@return false
+        local function always_false()
+            return false
+        end
+
+        local value = "before"
+        if always_false() then
+            ---@cast value integer
+        end
+        after = value
+        "#,
+        );
+
+        let after = ws.expr_ty("after");
+        assert_eq!(ws.humanize_type(after), r#""before""#);
+    }
+
     #[test]
     fn test_branch_join_keeps_union_when_only_one_side_narrows() {
         let mut ws = VirtualWorkspace::new();

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

@@ -26,14 +26,12 @@ pub(in crate::semantic) struct FlowAssignmentInfo {
 
 #[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)
-    }
+    Normal,
+    // Query one predecessor of a merge label; if that walk reaches an
+    // unreachable condition edge, it contributes `never` to the merged type.
+    MergeBranch,
+    // Re-query assignment antecedents without applying condition narrows.
+    IgnoreConditions,
 }
 
 #[derive(Debug, Default)]

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

@@ -121,6 +121,7 @@ pub(in crate::semantic) enum CorrelatedDiscriminantNarrow {
 #[derive(Debug, Clone)]
 pub(in crate::semantic) enum ConditionFlowAction {
     Continue,
+    Unreachable,
     Result(LuaType),
     Pending(PendingConditionNarrow),
     NeedExprType {
@@ -712,12 +713,12 @@ pub(in crate::semantic::infer::narrow) fn resolve_expr_type_continuation(
             condition_flow,
         ),
         ExprTypeContinuation::Truthiness { condition_flow } => Ok(match condition_flow {
-            _ if expr_type.is_never() => ConditionFlowAction::Result(LuaType::Never),
+            _ if expr_type.is_never() => ConditionFlowAction::Unreachable,
             InferConditionFlow::TrueCondition if expr_type.is_always_falsy() => {
-                ConditionFlowAction::Result(LuaType::Never)
+                ConditionFlowAction::Unreachable
             }
             InferConditionFlow::FalseCondition if expr_type.is_always_truthy() => {
-                ConditionFlowAction::Result(LuaType::Never)
+                ConditionFlowAction::Unreachable
             }
             _ => ConditionFlowAction::Continue,
         }),

crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_flow.rs

@@ -36,8 +36,7 @@ use crate::{
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-// One cached flow query: one ref at one flow node, optionally without replaying
-// pending condition narrows.
+// One cached flow query: one ref at one flow node under one flow mode.
 // Example: "what is `x` at flow 42, with current guards applied?"
 struct FlowQuery {
     var_ref_id: VarRefId,
@@ -52,7 +51,7 @@ impl FlowQuery {
             var_ref_id: var_ref_id.clone(),
             var_cache_idx: get_flow_cache_var_ref_id(cache, var_ref_id),
             flow_id,
-            mode: FlowMode::WithConditions,
+            mode: FlowMode::Normal,
         }
     }
 
@@ -583,10 +582,15 @@ impl<'a> FlowTypeEngine<'a> {
         // Branches are resumed from the end because the initial merge setup
         // schedules the last incoming branch first.
         let branch_idx = next_pending_idx - 1;
+        // The remaining predecessor is still a merge contribution. Preserve
+        // MergeBranch so an unreachable condition edge contributes `never`
+        // instead of continuing to the type from before the merge.
+        let branch_mode = match walk.query.mode {
+            FlowMode::Normal | FlowMode::MergeBranch => FlowMode::MergeBranch,
+            FlowMode::IgnoreConditions => FlowMode::IgnoreConditions,
+        };
         Ok(SchedulerStep::StartQuery {
-            query: walk
-                .query
-                .at_flow(branch_flow_ids[branch_idx], walk.query.mode),
+            query: walk.query.at_flow(branch_flow_ids[branch_idx], branch_mode),
             continuation: Some(Continuation::Merge {
                 walk,
                 branch_flow_ids,
@@ -613,12 +617,18 @@ impl<'a> FlowTypeEngine<'a> {
             Err(err) => return self.fail_query(&walk.query, err),
         };
 
+        // In MergeBranch mode, `never` from the antecedent query means this
+        // predecessor already crossed an unreachable condition edge.
+        if matches!(walk.query.mode, FlowMode::MergeBranch) && antecedent_type.is_never() {
+            return Ok(self.finish_walk(walk, LuaType::Never));
+        }
+
         if reuse_antecedent_narrowing
             && !can_reuse_narrowed_assignment_source(self.db, &antecedent_type, &expr_type)
         {
             let next_query = walk
                 .query
-                .at_flow(antecedent_flow_id, FlowMode::WithoutConditions);
+                .at_flow(antecedent_flow_id, FlowMode::IgnoreConditions);
             return Ok(SchedulerStep::StartQuery {
                 query: next_query,
                 continuation: Some(Continuation::AssignmentAntecedent {
@@ -826,6 +836,11 @@ impl<'a> FlowTypeEngine<'a> {
             // should still be narrowed by applying the cast from `unknown`.
             Err(_) => LuaType::Unknown,
         };
+        // In MergeBranch mode, `never` from the antecedent query means this
+        // predecessor already crossed an unreachable condition edge.
+        if matches!(walk.query.mode, FlowMode::MergeBranch) && cast_input_type.is_never() {
+            return Ok(self.finish_walk(walk, LuaType::Never));
+        }
         for cast_op_type in cast_op_types {
             cast_input_type = match cast_type(
                 self.db,
@@ -1116,14 +1131,17 @@ impl<'a> FlowTypeEngine<'a> {
         // Broad RHS types replace the previous runtime type. The old path still
         // queried the antecedent and then discarded it in finish_assignment_result.
         let reuse_antecedent_narrowing = preserves_assignment_expr_type(&expr_type);
-        if !expr_type.is_unknown() && !reuse_antecedent_narrowing {
+        if !expr_type.is_unknown()
+            && !reuse_antecedent_narrowing
+            && !matches!(walk.query.mode, FlowMode::MergeBranch)
+        {
             return Ok(self.finish_walk(walk, expr_type));
         }
 
-        let mode = if reuse_antecedent_narrowing {
-            FlowMode::WithConditions
-        } else {
-            FlowMode::WithoutConditions
+        let mode = match (walk.query.mode, reuse_antecedent_narrowing) {
+            (FlowMode::MergeBranch, _) => FlowMode::MergeBranch,
+            (_, true) => FlowMode::Normal,
+            (_, false) => FlowMode::IgnoreConditions,
         };
         let subquery = walk.query.at_flow(antecedent_flow_id, mode);
         Ok(SchedulerStep::StartQuery {
@@ -1179,7 +1197,7 @@ impl<'a> FlowTypeEngine<'a> {
         condition_flow: InferConditionFlow,
     ) -> Result<SchedulerStep, InferFailReason> {
         let antecedent_flow_id = get_single_antecedent(flow_node)?;
-        if !walk.query.mode.uses_conditions() {
+        if matches!(walk.query.mode, FlowMode::IgnoreConditions) {
             walk.antecedent_flow_id = antecedent_flow_id;
             return Ok(SchedulerStep::ContinueWalk(walk));
         }
@@ -1233,6 +1251,7 @@ impl<'a> FlowTypeEngine<'a> {
         if cached_action {
             return match action {
                 ConditionFlowAction::Continue => Ok(SchedulerStep::ContinueWalk(walk)),
+                ConditionFlowAction::Unreachable => Ok(self.finish_unreachable_condition(walk)),
                 ConditionFlowAction::Result(result_type) => Ok(self.finish_walk(walk, result_type)),
                 ConditionFlowAction::Pending(pending_condition_narrow) => {
                     let mut walk = walk;
@@ -1275,9 +1294,11 @@ impl<'a> FlowTypeEngine<'a> {
         }
 
         let antecedent_flow_id = get_single_antecedent(flow_node)?;
-        let subquery = walk
-            .query
-            .at_flow(antecedent_flow_id, FlowMode::WithConditions);
+        let mode = match walk.query.mode {
+            FlowMode::MergeBranch => FlowMode::MergeBranch,
+            FlowMode::Normal | FlowMode::IgnoreConditions => FlowMode::Normal,
+        };
+        let subquery = walk.query.at_flow(antecedent_flow_id, mode);
         Ok(SchedulerStep::StartQuery {
             query: subquery,
             continuation: Some(Continuation::TagCastAntecedent {
@@ -1315,13 +1336,28 @@ impl<'a> FlowTypeEngine<'a> {
                     } else {
                         Arc::<[FlowId]>::from(get_multi_antecedents(self.tree, flow_node)?)
                     };
-                    let Some(next_pending_idx) = branch_flow_ids.len().checked_sub(1) else {
-                        return Ok(self.finish_walk(walk, LuaType::Never));
-                    };
+                    match branch_flow_ids.len() {
+                        0 => return Ok(self.finish_walk(walk, LuaType::Never)),
+                        // A single predecessor is just a branch-entry label, not a merge.
+                        // Keep the current mode so queries inside an impossible then/else
+                        // body can still resolve unrelated symbols from their declarations.
+                        1 => {
+                            walk.antecedent_flow_id = branch_flow_ids[0];
+                            continue;
+                        }
+                        _ => {}
+                    }
+                    let next_pending_idx = branch_flow_ids.len() - 1;
                     let q = &walk.query;
-                    let next_query = q.at_flow(branch_flow_ids[next_pending_idx], q.mode);
+                    // Multiple predecessors make this a merge. Query each
+                    // predecessor as a merge contribution so an unreachable
+                    // condition edge contributes `never` to the final union.
+                    let branch_mode = match q.mode {
+                        FlowMode::Normal | FlowMode::MergeBranch => FlowMode::MergeBranch,
+                        FlowMode::IgnoreConditions => FlowMode::IgnoreConditions,
+                    };
                     return Ok(SchedulerStep::StartQuery {
-                        query: next_query,
+                        query: q.at_flow(branch_flow_ids[next_pending_idx], branch_mode),
                         continuation: Some(Continuation::Merge {
                             walk,
                             branch_flow_ids,
@@ -1453,6 +1489,15 @@ impl<'a> FlowTypeEngine<'a> {
                     );
                 Ok(SchedulerStep::ContinueWalk(walk))
             }
+            ConditionFlowAction::Unreachable => {
+                get_flow_var_cache(self.cache, walk.query.var_cache_idx)
+                    .condition_cache
+                    .insert(
+                        (flow_id, condition_flow),
+                        CacheEntry::Cache(ConditionFlowAction::Unreachable),
+                    );
+                Ok(self.finish_unreachable_condition(walk))
+            }
             ConditionFlowAction::Result(result_type) => {
                 get_flow_var_cache(self.cache, walk.query.var_cache_idx)
                     .condition_cache
@@ -1498,9 +1543,13 @@ impl<'a> FlowTypeEngine<'a> {
                 self.start_field_literal_sibling_subquery(walk, flow_id, condition_flow, subquery)
             ),
             ConditionFlowAction::NeedCorrelated(pending_correlated_condition) => {
+                let mode = match walk.query.mode {
+                    FlowMode::MergeBranch => FlowMode::MergeBranch,
+                    FlowMode::Normal | FlowMode::IgnoreConditions => FlowMode::Normal,
+                };
                 let subquery = walk.query.at_flow(
                     pending_correlated_condition.current_search_root_flow_id,
-                    FlowMode::WithConditions,
+                    mode,
                 );
                 Ok(SchedulerStep::StartQuery {
                     query: subquery,
@@ -1515,14 +1564,25 @@ impl<'a> FlowTypeEngine<'a> {
         }
     }
 
+    fn finish_unreachable_condition(&mut self, walk: QueryWalk) -> SchedulerStep {
+        // Unreachable describes the condition edge, not the queried symbol. A
+        // merge query asks what this branch contributes, so the answer is
+        // `never`; point queries continue to the antecedent so unrelated
+        // symbols inside impossible branches keep their declared types.
+        match walk.query.mode {
+            FlowMode::MergeBranch => self.finish_walk(walk, LuaType::Never),
+            FlowMode::Normal | FlowMode::IgnoreConditions => SchedulerStep::ContinueWalk(walk),
+        }
+    }
+
     fn finish_walk(&mut self, walk: QueryWalk, narrow_type: LuaType) -> SchedulerStep {
         let QueryWalk {
             query,
             pending_condition_narrows,
             ..
         } = walk;
         let mut final_type = narrow_type;
-        if query.mode.uses_conditions() {
+        if !matches!(query.mode, FlowMode::IgnoreConditions) {
             for pending_condition_narrow in pending_condition_narrows.into_iter().rev() {
                 final_type = pending_condition_narrow.apply(self.db, self.cache, final_type);
             }