refactor: new type check

Author: xuhuanzy

crates/emmylua_code_analysis/locales/lint.yml

@@ -287,3 +287,8 @@ Cannot use `...` outside a vararg function.:
   en: "Missing comment for function `%{name}`."
   zh_CN: "函数 `%{name}` 缺少注解。"
   zh_HK: "函式 `%{name}` 缺少註解。"
+
+"The target requires at least %{count} element(s) but source may have fewer.":
+  en: "The target requires at least %{count} element(s) but source may have fewer."
+  zh_CN: "目标最少需要 %{count} 个元素，但源可能更少。"
+  zh_HK: "目標最少需要 %{count} 個元素，但源可能更少。"

crates/emmylua_code_analysis/src/compilation/analyzer/unresolve/find_decl_function.rs

@@ -4,12 +4,12 @@ use smol_str::SmolStr;
 
 use crate::{
     InFiled, InferFailReason, InferGuardRef, LuaInferCache, LuaInstanceType, LuaMemberId,
-    LuaMemberOwner, LuaOperatorOwner, TypeOps, TypeSubstitutor, check_type_compact,
+    LuaMemberOwner, LuaOperatorOwner, TypeOps, TypeSubstitutor,
     db_index::{
         DbIndex, LuaGenericType, LuaIntersectionType, LuaMemberKey, LuaObjectType,
         LuaOperatorMetaMethod, LuaTupleType, LuaType, LuaTypeDeclId, LuaUnionType,
     },
-    infer_expr, instantiate_type_generic,
+    infer_expr, instantiate_type_generic, is_assignable,
     semantic::InferGuard,
 };
 
@@ -316,7 +316,7 @@ fn find_index_metamethod(
         LuaIndexKey::Expr(expr) => infer_expr(db, cache, expr.clone())?,
     };
 
-    if check_type_compact(db, key_type, &access_key_type).is_ok() {
+    if is_assignable(db, &access_key_type, key_type) {
         return Ok(value_type.clone());
     }
 
@@ -548,7 +548,7 @@ fn find_member_by_index_table(
                             LuaMemberKey::Integer(i) => LuaType::IntegerConst(*i),
                             _ => continue,
                         };
-                        if check_type_compact(db, &key_type, &member_key_type).is_ok() {
+                        if is_assignable(db, &member_key_type, &key_type) {
                             let member_type = db
                                 .get_type_index()
                                 .get_type_cache(&member.get_id().into())
@@ -663,7 +663,7 @@ fn infer_member_by_index_array(
     } else if member_key.is_expr() {
         let expr = member_key.get_expr().ok_or(InferFailReason::None)?;
         let expr_type = infer_expr(db, cache, expr.clone())?;
-        if check_type_compact(db, &LuaType::Number, &expr_type).is_ok() {
+        if is_assignable(db, &expr_type, &LuaType::Number) {
             return Ok(base.clone());
         }
     }
@@ -683,7 +683,7 @@ fn infer_member_by_index_object(
         let expr = member_key.get_expr().ok_or(InferFailReason::None)?;
         let expr_type = infer_expr(db, cache, expr.clone())?;
         for (key, field) in access_member_type {
-            if check_type_compact(db, key, &expr_type).is_ok() {
+            if is_assignable(db, &expr_type, key) {
                 return Ok(field.clone());
             }
         }

crates/emmylua_code_analysis/src/compilation/test/closure_return_test.rs

@@ -10,8 +10,8 @@ mod test {
         let ty = ws.expr_ty("result");
         let expected = ws.ty("integer");
         let nil = ws.ty("nil");
-        assert!(ws.check_type(&ty, &expected));
-        assert!(!ws.check_type(&ty, &nil));
+        assert!(ws.check_type(&expected, &ty));
+        assert!(!ws.check_type(&nil, &ty));
     }
 
     #[test]
@@ -364,8 +364,8 @@ mod test {
         let ty = ws.expr_ty("result");
         let expected = ws.ty("integer|string");
         let nil = ws.ty("nil");
-        assert!(ws.check_type(&ty, &expected));
-        assert!(!ws.check_type(&ty, &nil));
+        assert!(ws.check_type(&expected, &ty));
+        assert!(!ws.check_type(&nil, &ty));
     }
 
     #[test]
@@ -393,7 +393,7 @@ mod test {
         let ty = ws.expr_ty("result");
         let expected = ws.ty("integer|string");
         let nil = ws.ty("nil");
-        assert!(ws.check_type(&ty, &expected));
-        assert!(!ws.check_type(&ty, &nil));
+        assert!(ws.check_type(&expected, &ty));
+        assert!(!ws.check_type(&nil, &ty));
     }
 }

crates/emmylua_code_analysis/src/compilation/test/member_infer_test.rs

@@ -72,7 +72,7 @@ mod test {
 
         let result_ty = ws.expr_ty("Result");
         let expected_ty = ws.ty("string?");
-        assert!(ws.check_type(&result_ty, &expected_ty));
+        assert!(ws.check_type(&expected_ty, &result_ty));
     }
 
     #[test]

crates/emmylua_code_analysis/src/compilation/test/module_test.rs

@@ -139,8 +139,8 @@ mod test {
         let ty = ws.expr_ty(r#"require("virtual_0")"#);
         let integer = ws.ty("integer");
         let nil = ws.ty("nil");
-        assert!(ws.check_type(&ty, &integer));
-        assert!(!ws.check_type(&ty, &nil));
+        assert!(ws.check_type(&integer, &ty));
+        assert!(!ws.check_type(&nil, &ty));
     }
 
     #[test]

crates/emmylua_code_analysis/src/compilation/test/return_overload_generic_test.rs

@@ -161,17 +161,17 @@ mod test {
 
         let status_ty = ws.expr_ty("status");
         let boolean_ty = ws.ty("boolean");
-        assert!(ws.check_type(&status_ty, &boolean_ty));
+        assert!(ws.check_type(&boolean_ty, &status_ty));
         assert!(!status_ty.is_always_truthy());
         assert!(!status_ty.is_always_falsy());
 
         let value_ty = ws.expr_ty("value");
         let integer_or_string_ty = ws.ty("integer|string");
         let integer_ty = ws.ty("integer");
         let string_ty = ws.ty("string");
-        assert!(ws.check_type(&value_ty, &integer_or_string_ty));
-        assert!(ws.check_type(&value_ty, &integer_ty));
-        assert!(ws.check_type(&value_ty, &string_ty));
+        assert!(ws.check_type(&integer_or_string_ty, &value_ty));
+        assert!(ws.check_type(&integer_ty, &value_ty));
+        assert!(ws.check_type(&string_ty, &value_ty));
     }
 
     #[test]

crates/emmylua_code_analysis/src/db_index/member/lua_owner_members.rs

@@ -42,6 +42,10 @@ impl LuaOwnerMembers {
         self.members.values()
     }
 
+    pub fn iter(&self) -> impl Iterator<Item = (&LuaMemberKey, &LuaMemberIndexItem)> {
+        self.members.iter()
+    }
+
     pub fn iter_mut(&mut self) -> impl Iterator<Item = (&LuaMemberKey, &mut LuaMemberIndexItem)> {
         self.members.iter_mut()
     }

crates/emmylua_code_analysis/src/db_index/member/mod.rs

@@ -191,7 +191,13 @@ impl LuaMemberIndex {
         Some(members)
     }
 
-    #[allow(unused)]
+    pub fn get_member_items(
+        &self,
+        owner: &LuaMemberOwner,
+    ) -> Option<impl Iterator<Item = (&LuaMemberKey, &LuaMemberIndexItem)>> {
+        Some(self.owner_members.get(owner)?.iter())
+    }
+
     pub fn get_member_item_by_member_id(
         &self,
         member_id: LuaMemberId,

crates/emmylua_code_analysis/src/db_index/signature/signature.rs

@@ -153,9 +153,7 @@ impl LuaSignature {
                         return false;
                     }
 
-                    semantic_model
-                        .type_check(owner_type, &param_info.type_ref)
-                        .is_ok()
+                    semantic_model.is_assignable(&param_info.type_ref, owner_type)
                 }
                 None => param_info.name == "self",
             }

crates/emmylua_code_analysis/src/db_index/type/types/complex.rs

@@ -196,10 +196,10 @@ impl LuaFunctionType {
                             {
                                 return false;
                             }
-                            if semantic_model.type_check(owner_type, t).is_ok() {
+                            if semantic_model.is_assignable(t, owner_type) {
                                 return true;
                             }
-                            name == "self" && semantic_model.type_check(t, owner_type).is_ok()
+                            name == "self" && semantic_model.is_assignable(owner_type, t)
                         }
                         None => name == "self",
                     }
@@ -293,6 +293,19 @@ impl LuaObjectType {
         self.fields.get(key)
     }
 
+    pub fn get_member_type(&self, key: &LuaMemberKey) -> Option<LuaType> {
+        self.get_field(key).cloned().or_else(|| {
+            let LuaMemberKey::TypeKey(key_type) = key else {
+                return None;
+            };
+            self.index_access
+                .iter()
+                .find_map(|(index_type, value_type)| {
+                    (index_type == key_type).then(|| value_type.clone())
+                })
+        })
+    }
+
     pub fn contain_tpl(&self) -> bool {
         self.contain_tpl_children()
     }