fix: handle intersection type as table subtype and in undefined-field check

- Add Intersection to table compact-type match in check_general_type_compact (mod.rs)
- Add Intersection/Object handling in get_base_type_id (sub_type.rs)
- Add Intersection handling in is_invalid_prefix_type and is_valid_member (check_field.rs)

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/semantic/type_check/mod.rs

@@ -81,6 +81,25 @@ fn check_general_type_compact(
         );
     }
 
+    // When compact_type is an Intersection, the value satisfies all components simultaneously.
+    // So it can be assigned to any target that accepts at least one component.
+    // This must be handled before the source-based dispatch, because individual source branches
+    // (e.g. Array, Ref) do not know how to decompose an intersection compact_type.
+    if let LuaType::Intersection(compact_intersection) = compact_type {
+        // Skip if source is also Intersection — that case is handled symmetrically in
+        // check_intersection_type_compact.
+        if !matches!(source, LuaType::Intersection(_)) {
+            for component in compact_intersection.get_types() {
+                if check_general_type_compact(context, source, component, check_guard.next_level()?)
+                    .is_ok()
+                {
+                    return Ok(());
+                }
+            }
+            return Err(TypeCheckFailReason::TypeNotMatch);
+        }
+    }
+
     match source {
         LuaType::Unknown | LuaType::Any => Ok(()),
         // simple type

crates/emmylua_code_analysis/src/semantic/type_check/sub_type.rs

@@ -88,7 +88,11 @@ pub fn get_base_type_id(typ: &LuaType) -> Option<LuaTypeDeclId> {
         | LuaType::TableGeneric(_)
         | LuaType::TableConst(_)
         | LuaType::Tuple(_)
-        | LuaType::Array(_) => Some(LuaTypeDeclId::global("table")),
+        | LuaType::Array(_)
+        | LuaType::Object(_) => Some(LuaTypeDeclId::global("table")),
+        LuaType::Intersection(intersection) => {
+            intersection.get_types().iter().find_map(get_base_type_id)
+        }
         LuaType::DocFunction(_) | LuaType::Function | LuaType::Signature(_) => {
             Some(LuaTypeDeclId::global("function"))
         }