Merge pull request #1098 from lewis6991/fix/separate-unreachable-condition-flow

fix: separate unreachable conditions from never types

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs

@@ -199,7 +199,9 @@ pub fn bind_call_expr_stat(
         if let Some(ast) = LuaAst::cast(call_expr.syntax().clone()) {
             bind_each_child(binder, ast, current);
         }
-        current
+        let flow_id = binder.create_node(FlowNodeKind::CallExprStat(call_expr_stat.to_ptr()));
+        binder.add_antecedent(flow_id, current);
+        flow_id
     }
 }
 

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

@@ -307,6 +307,180 @@ 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_missing_field_assignment_does_not_contribute_to_merge() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@return false
+        local function is_windows()
+            return false
+        end
+
+        local command = "ls"
+        local config = {}
+        if is_windows() then
+            command = config.windows_command
+        end
+        after = command
+        "#,
+        );
+
+        let after = ws.expr_ty("after");
+        assert_eq!(ws.humanize_type(after), "string");
+    }
+
+    #[test]
+    fn test_reachable_assignment_over_never_value_contributes_to_merge() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+        ---@class NeverBox
+        ---@field value never
+
+        ---@return NeverBox
+        local function make_box() end
+
+        local value = make_box().value
+        local cond ---@type boolean
+        if cond then
+            value = 1
+        end
+        after = value
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("after"), LuaType::IntegerConst(1));
+    }
+
+    #[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();
@@ -1616,6 +1790,59 @@ end
         assert_eq!(b, LuaType::String);
     }
 
+    #[test]
+    fn test_issue_877_never_return_call_narrows_after_guard() {
+        let mut ws = VirtualWorkspace::new();
+
+        let source = r#"
+        ---@param _num integer
+        local function accept_num(_num)
+        end
+
+        ---@return never
+        local function panic()
+            error("panic!")
+        end
+
+        ---@type integer?
+        local num
+        if num == nil then
+            panic()
+        end
+
+        accept_num(num)
+        after_guard = num
+        "#;
+
+        assert!(ws.has_no_diagnostic(DiagnosticCode::ParamTypeMismatch, source));
+        assert_eq!(ws.expr_ty("after_guard"), LuaType::Integer);
+    }
+
+    #[test]
+    fn test_never_return_call_after_branch_statement_narrows_after_guard() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.def(
+            r#"
+        ---@return never
+        local function panic()
+            error("panic!")
+        end
+
+        ---@type integer?
+        local num
+        if num == nil then
+            local reason = "bad"
+            panic()
+        end
+
+        after_guard = num
+        "#,
+        );
+
+        assert_eq!(ws.expr_ty("after_guard"), LuaType::Integer);
+    }
+
     #[test]
     fn test_unknown_type() {
         let mut ws = VirtualWorkspace::new();

crates/emmylua_code_analysis/src/db_index/flow/flow_node.rs

@@ -1,6 +1,6 @@
 use emmylua_parser::{
-    LuaAssignStat, LuaAstNode, LuaAstPtr, LuaChunk, LuaClosureExpr, LuaDocTagCast, LuaExpr,
-    LuaForStat, LuaFuncStat, LuaSyntaxKind, LuaSyntaxNode,
+    LuaAssignStat, LuaAstNode, LuaAstPtr, LuaCallExprStat, LuaChunk, LuaClosureExpr, LuaDocTagCast,
+    LuaExpr, LuaForStat, LuaFuncStat, LuaSyntaxKind, LuaSyntaxNode,
 };
 use internment::ArcIntern;
 use rowan::{TextRange, TextSize};
@@ -44,6 +44,8 @@ pub enum FlowNodeKind {
     DeclPosition(TextSize),
     /// Variable assignment
     Assignment(LuaAstPtr<LuaAssignStat>),
+    /// Call expression statement
+    CallExprStat(LuaAstPtr<LuaCallExprStat>),
     /// Conditional flow (type guards, existence checks)
     TrueCondition(LuaAstPtr<LuaExpr>),
     /// Conditional flow (type guards, existence checks)

crates/emmylua_code_analysis/src/db_index/flow/flow_tree.rs

@@ -1,15 +1,18 @@
+use std::collections::VecDeque;
+
 use hashbrown::{HashMap, HashSet};
 
 use emmylua_parser::{LuaAstPtr, LuaCallExpr, LuaExpr, LuaSyntaxId};
 use rowan::TextSize;
 
-use crate::{FlowAntecedent, FlowId, FlowNode, LuaDeclId};
+use crate::{FlowAntecedent, FlowId, FlowNode, FlowNodeKind, LuaDeclId};
 
 #[derive(Debug)]
 pub struct FlowTree {
     decl_bind_expr_ref: HashMap<LuaDeclId, LuaAstPtr<LuaExpr>>,
     decl_multi_return_ref: HashMap<LuaDeclId, Vec<DeclMultiReturnRefAt>>,
     flow_nodes: Vec<FlowNode>,
+    has_tag_cast: bool,
     multiple_antecedents: Vec<Vec<FlowId>>,
     // labels: HashMap<LuaClosureId, HashMap<SmolStr, FlowId>>,
     bindings: HashMap<LuaSyntaxId, FlowId>,
@@ -24,10 +27,14 @@ impl FlowTree {
         // labels: HashMap<LuaClosureId, HashMap<SmolStr, FlowId>>,
         bindings: HashMap<LuaSyntaxId, FlowId>,
     ) -> Self {
+        let has_tag_cast = flow_nodes
+            .iter()
+            .any(|node| matches!(node.kind, FlowNodeKind::TagCast(_)));
         Self {
             decl_bind_expr_ref,
             decl_multi_return_ref,
             flow_nodes,
+            has_tag_cast,
             multiple_antecedents,
             bindings,
         }
@@ -41,12 +48,34 @@ impl FlowTree {
         self.flow_nodes.get(flow_id.0 as usize)
     }
 
+    pub fn has_tag_cast(&self) -> bool {
+        self.has_tag_cast
+    }
+
     pub fn get_multi_antecedents(&self, id: u32) -> Option<&[FlowId]> {
         self.multiple_antecedents
             .get(id as usize)
             .map(|v| v.as_slice())
     }
 
+    /// Returns the first backward-reachable flow node shared by all starting flows.
+    pub fn get_nearest_common_antecedent(&self, flow_ids: &[FlowId]) -> Option<FlowId> {
+        let (first_flow_id, rest_flow_ids) = flow_ids.split_first()?;
+        let first_antecedents = self.collect_antecedents(*first_flow_id);
+        let rest_antecedents = rest_flow_ids
+            .iter()
+            .map(|flow_id| {
+                self.collect_antecedents(*flow_id)
+                    .into_iter()
+                    .collect::<HashSet<_>>()
+            })
+            .collect::<Vec<_>>();
+
+        first_antecedents
+            .into_iter()
+            .find(|flow_id| rest_antecedents.iter().all(|set| set.contains(flow_id)))
+    }
+
     pub fn get_decl_ref_expr(&self, decl_id: &LuaDeclId) -> Option<LuaAstPtr<LuaExpr>> {
         self.decl_bind_expr_ref.get(decl_id).cloned()
     }
@@ -263,6 +292,35 @@ impl FlowTree {
             }
         }
     }
+
+    fn collect_antecedents(&self, flow_id: FlowId) -> Vec<FlowId> {
+        let mut antecedents = Vec::new();
+        let mut pending = VecDeque::from([flow_id]);
+        let mut visited = HashSet::new();
+        while let Some(flow_id) = pending.pop_front() {
+            if !visited.insert(flow_id) {
+                continue;
+            }
+
+            antecedents.push(flow_id);
+            let Some(flow_node) = self.get_flow_node(flow_id) else {
+                continue;
+            };
+            match flow_node.antecedent.as_ref() {
+                Some(FlowAntecedent::Single(antecedent_flow_id)) => {
+                    pending.push_back(*antecedent_flow_id);
+                }
+                Some(FlowAntecedent::Multiple(multi_id)) => {
+                    if let Some(branch_flow_ids) = self.get_multi_antecedents(*multi_id) {
+                        pending.extend(branch_flow_ids.iter().copied());
+                    }
+                }
+                None => {}
+            }
+        }
+
+        antecedents
+    }
 }
 
 #[derive(Debug, Clone)]

crates/emmylua_code_analysis/src/diagnostic/checker/assign_type_mismatch.rs

@@ -104,6 +104,10 @@ fn check_name_expr(
         }
         _ => None,
     };
+    let source_type = source_type.map(|source_type| {
+        semantic_model
+            .apply_assignment_target_casts(LuaExpr::NameExpr(name_expr.clone()), source_type)
+    });
     check_assign_type_mismatch(
         context,
         semantic_model,
@@ -139,6 +143,10 @@ fn check_index_expr(
         false,
     )
     .ok();
+    let source_type = source_type.map(|source_type| {
+        semantic_model
+            .apply_assignment_target_casts(LuaExpr::IndexExpr(index_expr.clone()), source_type)
+    });
 
     check_assign_type_mismatch(
         context,