fix: handle intersection type in undefined-field check, to avoid false positives on index access like values[1] for types such as Tuple & Object

Author: efve.zff

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

@@ -116,6 +116,9 @@ fn is_invalid_prefix_type(typ: &LuaType) -> bool {
             LuaType::Instance(instance_typ) => {
                 current_typ = instance_typ.get_base();
             }
+            LuaType::Intersection(intersection) => {
+                return intersection.get_types().iter().any(is_invalid_prefix_type);
+            }
             _ => return false,
         }
     }
@@ -141,6 +144,25 @@ pub(super) fn is_valid_member(
                 return None;
             }
         }
+        LuaType::Intersection(intersection) => {
+            // If any component of the intersection would pass the member check on its own,
+            // the intersection should also pass (e.g. unknown[] & { n: integer }).
+            for component in intersection.get_types() {
+                if is_valid_member(semantic_model, component, index_expr, index_key, code).is_some()
+                {
+                    return Some(());
+                }
+            }
+            // Even if no single component passes the early checks, the intersection's
+            // member lookup may still succeed (e.g. Tuple([Unknown]) & Object).
+            // Try inferring the index expression type directly.
+            if semantic_model
+                .get_index_decl_type(index_expr.clone())
+                .is_some()
+            {
+                return Some(());
+            }
+        }
         _ => {}
     }
 

crates/emmylua_code_analysis/src/diagnostic/test/undefined_field_test.rs

@@ -818,4 +818,30 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_intersection_array_index_access() {
+        let mut ws = VirtualWorkspace::new_with_init_std_lib();
+
+        // Accessing [1] on an intersection type containing an array should not report undefined-field
+        assert!(ws.check_code_for(
+            DiagnosticCode::UndefinedField,
+            r#"
+            function test(...)
+                local values = table.pack(...)
+                local e = values[1]
+            end
+            "#
+        ));
+
+        // Explicit intersection type annotation
+        assert!(ws.check_code_for(
+            DiagnosticCode::UndefinedField,
+            r#"
+            ---@type integer[] & { n: integer }
+            local values
+            local e = values[1]
+            "#
+        ));
+    }
 }