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.

Carry branch reachability as an internal flow-query result instead of inferring
it from `LuaType::Never`. Assignment and cast continuations can then distinguish
an unreachable predecessor from an ordinary type result that happens to be
`never`.

Preserve merge-branch mode through assignment, tag-cast, and correlated
condition subqueries. That prevents assignments, annotated 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, annotated-assignment, and cast merge contributions.

Assisted-by: Codex

Author: lewis6991

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

@@ -304,6 +304,134 @@ 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_false_call_condition_doc_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
+            ---@type integer
+            value = 1
+        end
+        after = value
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("after"), ws.ty("string"));
+    }
+
     #[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,19 +26,32 @@ pub(in crate::semantic) struct FlowAssignmentInfo {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub(in crate::semantic) enum FlowMode {
-    WithConditions,
-    WithoutConditions,
+    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,
 }
 
-impl FlowMode {
-    pub fn uses_conditions(self) -> bool {
-        matches!(self, Self::WithConditions)
+#[derive(Debug, Clone)]
+pub(in crate::semantic) enum FlowQueryResult {
+    Type(LuaType),
+    Unreachable,
+}
+
+impl FlowQueryResult {
+    pub(in crate::semantic) fn into_type(self) -> LuaType {
+        match self {
+            Self::Type(typ) => typ,
+            Self::Unreachable => LuaType::Never,
+        }
     }
 }
 
 #[derive(Debug, Default)]
 pub(in crate::semantic) struct FlowVarCache {
-    pub type_cache: HashMap<(FlowId, FlowMode), CacheEntry<LuaType>>,
+    pub type_cache: HashMap<(FlowId, FlowMode), CacheEntry<FlowQueryResult>>,
     pub condition_cache: HashMap<(FlowId, InferConditionFlow), CacheEntry<ConditionFlowAction>>,
 }
 

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,
         }),