type_check 支持 enum -> calss

Author: xuhuanzy

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

@@ -704,4 +704,56 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_super_and_enum_1() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(ws.check_code_for(
+            DiagnosticCode::ParamTypeNotMatch,
+            r#"
+                ---@enum AbilityType
+                local AbilityType = {
+                    HIDE   = 0,
+                    NORMAL = 1,
+                    COMMON = 2,
+                    HERO   = 3,
+                }
+                ---@class py.AbilityType: integer
+
+                ---@param ability_type py.AbilityType
+                local function a(ability_type) end
+
+                ---@param type AbilityType
+                local function get(type)
+                    local py_list = a(type)
+                end
+        "#
+        ));
+    }
+
+    #[test]
+    fn test_super_and_enum_2() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.check_code_for(
+            DiagnosticCode::ParamTypeNotMatch,
+            r#"
+                ---@enum AbilityType
+                local AbilityType = {
+                    HIDE   = "a",
+                    NORMAL = 1,
+                    COMMON = 2,
+                    HERO   = 3,
+                }
+                ---@class py.AbilityType: integer
+
+                ---@param ability_type py.AbilityType
+                local function a(ability_type) end
+
+                ---@param type AbilityType
+                local function get(type)
+                    local py_list = a(type)
+                end
+        "#
+        ));
+    }
 }

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

@@ -137,7 +137,7 @@ pub fn check_ref_type_compact(
                 for typ in union_types {
                     match check_general_type_compact(
                         db,
-                        compact_type,
+                        &LuaType::Ref(source_id.clone()),
                         &typ,
                         check_guard.next_level()?,
                     ) {
@@ -168,6 +168,29 @@ pub fn check_ref_type_compact(
         if is_sub_type_of(db, source_id, &compact_id) {
             return Ok(());
         }
+
+        // `compact`为枚举时也需要额外处理
+        if let LuaType::Ref(compact_id) = compact_type {
+            if let Some(compact_decl) = db.get_type_index().get_type_decl(compact_id) {
+                if compact_decl.is_enum() {
+                    let source = LuaType::Ref(source_id.clone());
+                    if let Some(LuaType::Union(enum_fields)) = compact_decl.get_enum_field_type(db)
+                    {
+                        let is_match = enum_fields.get_types().iter().all(|field| {
+                            let next_guard = check_guard.next_level();
+                            if next_guard.is_err() {
+                                return false;
+                            }
+                            check_general_type_compact(db, &source, field, next_guard.unwrap())
+                                .is_ok()
+                        });
+                        if is_match {
+                            return Ok(());
+                        }
+                    }
+                }
+            }
+        }
     }
 
     Err(TypeCheckFailReason::TypeNotMatch)