Fix #868

Author: CppCXY

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

@@ -1459,4 +1459,21 @@ _2 = a[1]
         let e_expected = ws.ty("string");
         assert_eq!(e, e_expected);
     }
+
+    #[test]
+    fn test_issue_868() {
+        let mut ws = VirtualWorkspace::new();
+
+        ws.check_code_for(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+            local a --- @type string|{foo:boolean, bar:string}
+
+            if a.foo then
+                --- @type string
+                local _ = a.bar
+            end
+            "#,
+        );
+    }
 }

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

@@ -1,9 +1,10 @@
-use emmylua_parser::{LuaChunk, LuaExpr, LuaIndexExpr};
+use emmylua_parser::{LuaChunk, LuaExpr, LuaIndexExpr, LuaIndexMemberExpr};
 
 use crate::{
-    DbIndex, FlowNode, FlowTree, InferFailReason, LuaInferCache,
+    DbIndex, FlowNode, FlowTree, InferFailReason, InferGuard, LuaInferCache, LuaType, TypeOps,
     semantic::infer::{
         VarRefId,
+        infer_index::infer_member_by_member_key,
         narrow::{
             ResultTypeOrContinue, condition_flow::InferConditionFlow, get_single_antecedent,
             get_type_at_flow::get_type_at_flow, narrow_false_or_nil, remove_false_or_nil,
@@ -30,7 +31,16 @@ pub fn get_type_at_index_expr(
     };
 
     if name_var_ref_id != *var_ref_id {
-        return Ok(ResultTypeOrContinue::Continue);
+        return maybe_field_exist_narrow(
+            db,
+            tree,
+            cache,
+            root,
+            var_ref_id,
+            flow_node,
+            index_expr,
+            condition_flow,
+        );
     }
 
     let antecedent_flow_id = get_single_antecedent(tree, flow_node)?;
@@ -43,3 +53,71 @@ pub fn get_type_at_index_expr(
 
     Ok(ResultTypeOrContinue::Result(result_type))
 }
+
+#[allow(clippy::too_many_arguments)]
+fn maybe_field_exist_narrow(
+    db: &DbIndex,
+    tree: &FlowTree,
+    cache: &mut LuaInferCache,
+    root: &LuaChunk,
+    var_ref_id: &VarRefId,
+    flow_node: &FlowNode,
+    index_expr: LuaIndexExpr,
+    condition_flow: InferConditionFlow,
+) -> Result<ResultTypeOrContinue, InferFailReason> {
+    let Some(prefix_expr) = index_expr.get_prefix_expr() else {
+        return Ok(ResultTypeOrContinue::Continue);
+    };
+
+    let Some(maybe_var_ref_id) = get_var_expr_var_ref_id(db, cache, prefix_expr.clone()) else {
+        // If we cannot find a reference declaration ID, we cannot narrow it
+        return Ok(ResultTypeOrContinue::Continue);
+    };
+
+    if maybe_var_ref_id != *var_ref_id {
+        return Ok(ResultTypeOrContinue::Continue);
+    }
+
+    let antecedent_flow_id = get_single_antecedent(tree, flow_node)?;
+    let left_type = get_type_at_flow(db, tree, cache, root, var_ref_id, antecedent_flow_id)?;
+    let LuaType::Union(union_type) = &left_type else {
+        return Ok(ResultTypeOrContinue::Continue);
+    };
+
+    let index = LuaIndexMemberExpr::IndexExpr(index_expr);
+    let mut result = vec![];
+    let union_types = union_type.into_vec();
+    for sub_type in &union_types {
+        let member_type = match infer_member_by_member_key(
+            db,
+            cache,
+            sub_type,
+            index.clone(),
+            &InferGuard::new(),
+        ) {
+            Ok(member_type) => member_type,
+            Err(_) => continue, // If we cannot infer the member type, skip this type
+        };
+        // donot use always true
+        if !member_type.is_always_falsy() {
+            result.push(sub_type.clone());
+        }
+    }
+
+    match condition_flow {
+        InferConditionFlow::TrueCondition => {
+            if !result.is_empty() {
+                return Ok(ResultTypeOrContinue::Result(LuaType::from_vec(result)));
+            }
+        }
+        InferConditionFlow::FalseCondition => {
+            if !result.is_empty() {
+                let target = LuaType::from_vec(result);
+                let t = TypeOps::Remove.apply(db, &left_type, &target);
+                return Ok(ResultTypeOrContinue::Result(t));
+            }
+        }
+    }
+
+    Ok(ResultTypeOrContinue::Continue)
+}