fix: handle intersection type as table subtype, to allow types like [T...] & { n: integer } to be assignable to table

Author: efve.zff

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/simple_type.rs

@@ -41,6 +41,7 @@ pub fn check_simple_type_compact(
                     | LuaType::Global
                     | LuaType::Userdata
                     | LuaType::Instance(_)
+                    | LuaType::Intersection(_)
                     | LuaType::Any
             ) {
                 return Ok(());

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

@@ -88,7 +88,21 @@ 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) => {
+            let all_table = intersection.get_types().iter().all(|t| {
+                matches!(
+                    get_base_type_id(t),
+                    Some(id) if id == LuaTypeDeclId::global("table")
+                )
+            });
+            if all_table {
+                Some(LuaTypeDeclId::global("table"))
+            } else {
+                None
+            }
+        }
         LuaType::DocFunction(_) | LuaType::Function | LuaType::Signature(_) => {
             Some(LuaTypeDeclId::global("function"))
         }

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

@@ -209,6 +209,94 @@ mod test {
         ));
     }
 
+    #[test]
+    fn test_intersection_is_table_subtype() {
+        let mut ws = VirtualWorkspace::new();
+
+        // [integer] & { n: integer } should be assignable to table
+        let intersection_ty = ws.ty("integer[] & { n: integer }");
+        let table_ty = ws.ty("table");
+        assert!(
+            ws.check_type(&table_ty, &intersection_ty),
+            "integer[] & {{ n: integer }} should be a subtype of table"
+        );
+
+        // Verify via diagnostic: passing intersection type to a table parameter should not error
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            ---@param t table
+            local function foo(t) end
+
+            ---@type integer[] & { n: integer }
+            local packed
+            foo(packed)
+            "#
+        ));
+
+        // Also verify: assigning intersection to table should not error
+        assert!(ws.check_code_for(
+            DiagnosticCode::AssignTypeMismatch,
+            r#"
+            ---@type integer[] & { n: integer }
+            local packed
+
+            ---@type table
+            local t = packed
+            "#
+        ));
+
+        // Intersection type should be assignable to an array type (non-generic)
+        let array_ty = ws.ty("integer[]");
+        assert!(
+            ws.check_type(&array_ty, &intersection_ty),
+            "integer[] & {{ n: integer }} should be assignable to integer[]"
+        );
+
+        // Intersection type should be assignable to an array parameter (non-generic)
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            ---@param t integer[]
+            local function foo2(t) end
+
+            ---@type integer[] & { n: integer }
+            local packed
+            foo2(packed)
+            "#
+        ));
+
+        // Intersection type should be assignable to a generic array parameter
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            ---@generic V
+            ---@param t V[]
+            ---@return fun(): integer, V
+            local function my_ipairs(t) end
+
+            ---@type integer[] & { n: integer }
+            local packed
+            my_ipairs(packed)
+            "#
+        ));
+
+        // Intersection type should be assignable to table<int, V>
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeMismatch,
+            r#"
+            ---@generic V
+            ---@param t table<integer, V>
+            ---@return fun(): integer, V
+            local function my_iter(t) end
+
+            ---@type integer[] & { n: integer }
+            local packed
+            my_iter(packed)
+            "#
+        ));
+    }
+
     #[test]
     fn test_set_index_expr_owner_prefers_declared_global_type() {
         let mut ws = VirtualWorkspace::new_with_init_std_lib();