refactor type check

Author: CppCXY

crates/emmylua_code_analysis/src/semantic/type_check/complex_type/array_type_check.rs

@@ -1,21 +1,24 @@
 use crate::{
-    DbIndex, LuaMemberKey, LuaMemberOwner, LuaType, TypeCheckFailReason, TypeCheckResult, TypeOps,
+    LuaMemberKey, LuaMemberOwner, LuaType, TypeCheckFailReason, TypeCheckResult, TypeOps,
     find_index_operations,
-    semantic::type_check::{check_general_type_compact, type_check_guard::TypeCheckGuard},
+    semantic::type_check::{
+        check_general_type_compact, type_check_context::TypeCheckContext,
+        type_check_guard::TypeCheckGuard,
+    },
 };
 
 pub fn check_array_type_compact(
-    db: &DbIndex,
+    context: &TypeCheckContext,
     source_base: &LuaType,
     compact_type: &LuaType,
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
-    let source_base = TypeOps::Union.apply(db, source_base, &LuaType::Nil);
+    let source_base = TypeOps::Union.apply(context.db, source_base, &LuaType::Nil);
 
     match compact_type {
         LuaType::Array(compact_array_type) => {
             return check_general_type_compact(
-                db,
+                context,
                 &source_base,
                 compact_array_type.get_base(),
                 check_guard.next_level()?,
@@ -24,7 +27,7 @@ pub fn check_array_type_compact(
         LuaType::Tuple(tuple_type) => {
             for element_type in tuple_type.get_types() {
                 check_general_type_compact(
-                    db,
+                    context,
                     &source_base,
                     element_type,
                     check_guard.next_level()?,
@@ -36,18 +39,18 @@ pub fn check_array_type_compact(
         LuaType::TableConst(inst) => {
             let table_member_owner = LuaMemberOwner::Element(inst.clone());
             return check_array_type_compact_table(
-                db,
+                context,
                 &source_base,
                 table_member_owner,
                 check_guard.next_level()?,
             );
         }
         LuaType::Object(compact_object) => {
             let compact_base = compact_object
-                .cast_down_array_base(db)
+                .cast_down_array_base(context.db)
                 .ok_or(TypeCheckFailReason::TypeNotMatch)?;
             return check_general_type_compact(
-                db,
+                context,
                 &source_base,
                 &compact_base,
                 check_guard.next_level()?,
@@ -57,7 +60,12 @@ pub fn check_array_type_compact(
         LuaType::TableGeneric(compact_types) => {
             if compact_types.len() == 2 {
                 for typ in compact_types.iter() {
-                    check_general_type_compact(db, &source_base, typ, check_guard.next_level()?)?;
+                    check_general_type_compact(
+                        context,
+                        &source_base,
+                        typ,
+                        check_guard.next_level()?,
+                    )?;
                 }
 
                 return Ok(());
@@ -66,7 +74,7 @@ pub fn check_array_type_compact(
         LuaType::Any => return Ok(()),
         LuaType::Ref(_) | LuaType::Def(_) => {
             return check_array_type_compact_ref_def(
-                db,
+                context,
                 &source_base,
                 compact_type,
                 check_guard.next_level()?,
@@ -79,20 +87,21 @@ pub fn check_array_type_compact(
 }
 
 fn check_array_type_compact_ref_def(
-    db: &DbIndex,
+    context: &TypeCheckContext,
     source_base: &LuaType,
     compact_type: &LuaType,
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
-    let Some(members) = find_index_operations(db, compact_type) else {
+    let Some(members) = find_index_operations(context.db, compact_type) else {
         return Err(TypeCheckFailReason::TypeNotMatch);
     };
 
     for member in &members {
         match &member.key {
             LuaMemberKey::ExprType(key_type) => {
                 if key_type.is_integer() {
-                    match check_general_type_compact(db, source_base, &member.typ, check_guard) {
+                    match check_general_type_compact(context, source_base, &member.typ, check_guard)
+                    {
                         Ok(()) => return Ok(()),
                         _ => {}
                     }
@@ -106,21 +115,26 @@ fn check_array_type_compact_ref_def(
 }
 
 fn check_array_type_compact_table(
-    db: &DbIndex,
+    context: &TypeCheckContext,
     source_base: &LuaType,
     table_owner: LuaMemberOwner,
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
-    let member_index = db.get_member_index();
+    let member_index = context.db.get_member_index();
 
     let member_len = member_index.get_member_len(&table_owner);
     for i in 0..member_len {
         let key = LuaMemberKey::Integer((i + 1) as i64);
         if let Some(member_item) = member_index.get_member_item(&table_owner, &key) {
             let member_type = member_item
-                .resolve_type(db)
+                .resolve_type(context.db)
                 .map_err(|_| TypeCheckFailReason::TypeNotMatch)?;
-            check_general_type_compact(db, source_base, &member_type, check_guard.next_level()?)?;
+            check_general_type_compact(
+                context,
+                source_base,
+                &member_type,
+                check_guard.next_level()?,
+            )?;
         } else {
             return Err(TypeCheckFailReason::TypeNotMatch);
         }

crates/emmylua_code_analysis/src/semantic/type_check/complex_type/intersection_type_check.rs

@@ -1,17 +1,20 @@
 use crate::{
-    DbIndex, LuaIntersectionType, LuaMemberOwner, LuaType, TypeCheckFailReason, TypeCheckResult,
-    semantic::type_check::{check_general_type_compact, type_check_guard::TypeCheckGuard},
+    LuaIntersectionType, LuaMemberOwner, LuaType, TypeCheckFailReason, TypeCheckResult,
+    semantic::type_check::{
+        check_general_type_compact, type_check_context::TypeCheckContext,
+        type_check_guard::TypeCheckGuard,
+    },
 };
 
 pub fn check_intersection_type_compact(
-    db: &DbIndex,
+    context: &TypeCheckContext,
     source_intersection: &LuaIntersectionType,
     compact_type: &LuaType,
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
     match compact_type {
         LuaType::TableConst(range) => check_intersection_type_compact_table(
-            db,
+            context,
             source_intersection,
             LuaMemberOwner::Element(range.clone()),
             check_guard.next_level()?,
@@ -20,7 +23,7 @@ pub fn check_intersection_type_compact(
             // 检查对象是否满足交叉类型的所有组成部分
             for intersection_component in source_intersection.get_types() {
                 check_general_type_compact(
-                    db,
+                    context,
                     intersection_component,
                     compact_type,
                     check_guard.next_level()?,
@@ -31,7 +34,7 @@ pub fn check_intersection_type_compact(
         LuaType::Intersection(compact_intersection) => {
             // 交叉类型对交叉类型：检查所有组成部分
             check_intersection_type_compact_intersection(
-                db,
+                context,
                 source_intersection,
                 compact_intersection,
                 check_guard.next_level()?,
@@ -42,7 +45,7 @@ pub fn check_intersection_type_compact(
             // 对于其他类型，检查是否至少满足一个组成部分
             for intersection_component in source_intersection.get_types() {
                 if check_general_type_compact(
-                    db,
+                    context,
                     intersection_component,
                     compact_type,
                     check_guard.next_level()?,
@@ -58,15 +61,15 @@ pub fn check_intersection_type_compact(
 }
 
 fn check_intersection_type_compact_table(
-    db: &DbIndex,
+    context: &TypeCheckContext,
     source_intersection: &LuaIntersectionType,
     table_owner: LuaMemberOwner,
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
     // 交叉类型要求 TableConst 必须满足所有组成部分
     for intersection_component in source_intersection.get_types() {
         check_general_type_compact(
-            db,
+            context,
             intersection_component,
             &LuaType::TableConst(
                 table_owner
@@ -82,7 +85,7 @@ fn check_intersection_type_compact_table(
 }
 
 fn check_intersection_type_compact_intersection(
-    db: &DbIndex,
+    context: &TypeCheckContext,
     source_intersection: &LuaIntersectionType,
     compact_intersection: &LuaIntersectionType,
     check_guard: TypeCheckGuard,
@@ -93,7 +96,7 @@ fn check_intersection_type_compact_intersection(
 
         for compact_component in compact_intersection.get_types() {
             if check_general_type_compact(
-                db,
+                context,
                 source_component,
                 compact_component,
                 check_guard.next_level()?,

crates/emmylua_code_analysis/src/semantic/type_check/complex_type/mod.rs

@@ -10,7 +10,7 @@ use object_type_check::check_object_type_compact;
 use table_generic_check::check_table_generic_type_compact;
 use tuple_type_check::check_tuple_type_compact;
 
-use crate::{DbIndex, LuaType, LuaUnionType};
+use crate::{semantic::type_check::type_check_context::TypeCheckContext, LuaType, LuaUnionType};
 
 use super::{
     TypeCheckResult, check_general_type_compact, type_check_fail_reason::TypeCheckFailReason,
@@ -19,15 +19,15 @@ use super::{
 
 // all is duck typing
 pub fn check_complex_type_compact(
-    db: &DbIndex,
+    context: &TypeCheckContext,
     source: &LuaType,
     compact_type: &LuaType,
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
     match source {
         LuaType::Array(source_array_type) => {
             match check_array_type_compact(
-                db,
+                context,
                 source_array_type.get_base(),
                 compact_type,
                 check_guard,
@@ -37,20 +37,20 @@ pub fn check_complex_type_compact(
             }
         }
         LuaType::Tuple(tuple) => {
-            match check_tuple_type_compact(db, &tuple, compact_type, check_guard) {
+            match check_tuple_type_compact(context, &tuple, compact_type, check_guard) {
                 Err(TypeCheckFailReason::DonotCheck) => {}
                 result => return result,
             }
         }
         LuaType::Object(source_object) => {
-            match check_object_type_compact(db, source_object, compact_type, check_guard) {
+            match check_object_type_compact(context, source_object, compact_type, check_guard) {
                 Err(TypeCheckFailReason::DonotCheck) => {}
                 result => return result,
             }
         }
         LuaType::TableGeneric(source_generic_param) => {
             match check_table_generic_type_compact(
-                db,
+                context,
                 source_generic_param,
                 compact_type,
                 check_guard,
@@ -61,7 +61,7 @@ pub fn check_complex_type_compact(
         }
         LuaType::Intersection(source_intersection) => {
             match check_intersection_type_compact(
-                db,
+                context,
                 source_intersection,
                 compact_type,
                 check_guard,
@@ -74,7 +74,7 @@ pub fn check_complex_type_compact(
             match compact_type {
                 LuaType::Union(compact_union) => {
                     return check_union_type_compact_union(
-                        db,
+                        context,
                         source,
                         compact_union,
                         check_guard.next_level()?,
@@ -84,7 +84,7 @@ pub fn check_complex_type_compact(
             }
             for sub_type in union_type.into_vec() {
                 match check_general_type_compact(
-                    db,
+                    context,
                     &sub_type,
                     compact_type,
                     check_guard.next_level()?,
@@ -104,7 +104,7 @@ pub fn check_complex_type_compact(
         LuaType::MultiLineUnion(multi_union) => {
             let union = multi_union.to_union();
             return check_complex_type_compact(
-                db,
+                context,
                 &union,
                 &compact_type,
                 check_guard.next_level()?,
@@ -115,7 +115,7 @@ pub fn check_complex_type_compact(
     // Do I need to check union types?
     if let LuaType::Union(union) = compact_type {
         for sub_compact in union.into_vec() {
-            match check_complex_type_compact(db, source, &sub_compact, check_guard.next_level()?) {
+            match check_complex_type_compact(context, source, &sub_compact, check_guard.next_level()?) {
                 Ok(_) => {}
                 Err(e) => return Err(e),
             }
@@ -129,14 +129,14 @@ pub fn check_complex_type_compact(
 
 // too complex
 fn check_union_type_compact_union(
-    db: &DbIndex,
+    context: &TypeCheckContext,
     source: &LuaType,
     compact_union: &LuaUnionType,
     check_guard: TypeCheckGuard,
 ) -> TypeCheckResult {
     let compact_types = compact_union.into_vec();
     for compact_sub_type in compact_types {
-        check_general_type_compact(db, source, &compact_sub_type, check_guard.next_level()?)?;
+        check_general_type_compact(context, source, &compact_sub_type, check_guard.next_level()?)?;
     }
 
     Ok(())