improve type check

Author: CppCXY

CHANGELOG.md

@@ -27,6 +27,8 @@
 
 `FIX` Fix inference issue by resolving iteration order problem.
 
+`FIX` Improve type check
+
 # 0.4.6
 
 `FIX` Fix issue with executable file directory hierarchy being too deep.

Cargo.lock

@@ -74,7 +74,7 @@ fn check_call_expr(
                         expr_type = LuaType::Any;
                     }
 
-                    if !semantic_model.check_type_compact(&param_type, &expr_type) {
+                    if !semantic_model.type_check(&param_type, &expr_type) {
                         let db = semantic_model.get_db();
                         context.add_diagnostic(
                             DiagnosticCode::ParamTypeNotMatch,
@@ -103,7 +103,7 @@ fn check_call_expr(
                 expr_type = LuaType::Any;
             }
 
-            if !semantic_model.check_type_compact(&param_type, &expr_type) {
+            if !semantic_model.type_check(&param_type, &expr_type) {
                 let db = semantic_model.get_db();
                 context.add_diagnostic(
                     DiagnosticCode::ParamTypeNotMatch,

crates/emmylua_code_analysis/src/diagnostic/checker/param_type_check.rs

@@ -14,7 +14,7 @@ use crate::{
     semantic::{
         instantiate::{instantiate_type, TypeSubstitutor},
         member::{get_buildin_type_map_type_id, without_index_operator, without_members},
-        type_compact::check_type_compact,
+        type_check::check_type_compact,
         InferGuard,
     },
     InFiled, LuaInstanceType, TypeOps,

crates/emmylua_code_analysis/src/semantic/infer/infer_index.rs

@@ -6,7 +6,7 @@ mod overload_resolve;
 mod reference;
 mod semantic_info;
 mod type_calc;
-mod type_compact;
+mod type_check;
 mod visibility;
 
 use std::cell::RefCell;
@@ -24,7 +24,7 @@ use semantic_info::{
     infer_node_property_owner, infer_node_semantic_info, infer_token_property_owner,
     infer_token_semantic_info,
 };
-use type_compact::{check_type_compact, is_sub_type_of};
+use type_check::{check_type_compact, is_sub_type_of};
 use visibility::check_visibility;
 
 use crate::LuaFunctionType;
@@ -100,7 +100,7 @@ impl<'a> SemanticModel<'a> {
         infer_members(self.db, prefix_type)
     }
 
-    pub fn check_type_compact(&self, source: &LuaType, compact_type: &LuaType) -> bool {
+    pub fn type_check(&self, source: &LuaType, compact_type: &LuaType) -> bool {
         check_type_compact(
             self.db,
             &mut self.infer_config.borrow_mut(),

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -5,7 +5,7 @@ use emmylua_parser::LuaCallExpr;
 use crate::db_index::{DbIndex, LuaFunctionType, LuaType};
 
 use super::{
-    infer_expr, instantiate::instantiate_func, type_compact::check_type_compact, LuaInferConfig,
+    infer_expr, instantiate::instantiate_func, type_check::check_type_compact, LuaInferConfig,
 };
 
 pub fn resolve_signature(

crates/emmylua_code_analysis/src/semantic/overload_resolve/mod.rs

@@ -61,13 +61,13 @@ fn infer_type_compact(
         (_, LuaType::MemberPathExist(right)) => {
             infer_type_compact(db, config, source, &right.get_origin(), infer_guard)
         }
-        (LuaType::BooleanConst(_), _) => compact_type.is_boolean(),
-        (LuaType::IntegerConst(_), _) => compact_type.is_number(),
-        (LuaType::StringConst(_), _) => compact_type.is_string(),
-        (LuaType::Number, _) => compact_type.is_number(),
-        (LuaType::Integer, _) => compact_type.is_integer(),
-        (LuaType::String, _) => compact_type.is_string(),
-        (LuaType::Boolean, _) => compact_type.is_boolean(),
+        (LuaType::BooleanConst(_), right) if right.is_boolean() => true,
+        (LuaType::IntegerConst(_), right) if right.is_number() => true,
+        (LuaType::StringConst(_), right) if right.is_string() => true,
+        (LuaType::Number, right) if right.is_number() => true,
+        (LuaType::Integer, right) if right.is_integer() => true,
+        (LuaType::String, right) if right.is_string() => true,
+        (LuaType::Boolean, right) if right.is_boolean() => true,
         (LuaType::DocIntegerConst(i), _) => match compact_type {
             LuaType::IntegerConst(j) => *i == j,
             LuaType::DocIntegerConst(j) => *i == j,
@@ -111,7 +111,9 @@ fn infer_type_compact(
                 .unwrap_or(false)
         }
         (LuaType::Array(a), LuaType::Array(b)) => infer_type_compact(db, config, a, b, infer_guard),
-        (LuaType::Array(a), _) => infer_array_type_compact_by_element_type(db, config, a, &compact_type, infer_guard),
+        (LuaType::Array(a), _) => {
+            infer_array_type_compact_by_element_type(db, config, a, &compact_type, infer_guard)
+        }
         (LuaType::Tuple(a), LuaType::Tuple(b)) => {
             infer_tuple_type_compact(db, config, a, b, infer_guard).unwrap_or(false)
         }
@@ -124,6 +126,11 @@ fn infer_type_compact(
             .get_types()
             .iter()
             .any(|t| infer_type_compact(db, config, t, &compact_type, infer_guard)),
+        (left, LuaType::Union(b)) if !left.is_union() => b
+            .get_types()
+            .iter()
+            .all(|t| infer_type_compact(db, config, left, t, infer_guard)),
+
         (LuaType::Intersection(a), _) => a
             .get_types()
             .iter()
@@ -366,13 +373,14 @@ fn infer_array_type_compact_by_element_type(
     infer_guard: &mut InferGuard,
 ) -> bool {
     match compact_type {
-        LuaType::Array(element_type) => infer_type_compact(db, config, source_element_type, element_type, infer_guard),
-        LuaType::Tuple(tuple_type) =>
-            tuple_type.get_types()
-                .into_iter()
-                .all(|element_type| infer_type_compact(db, config, source_element_type, element_type, infer_guard)),
+        LuaType::Array(element_type) => {
+            infer_type_compact(db, config, source_element_type, element_type, infer_guard)
+        }
+        LuaType::Tuple(tuple_type) => tuple_type.get_types().into_iter().all(|element_type| {
+            infer_type_compact(db, config, source_element_type, element_type, infer_guard)
+        }),
         // TODO implement the check for table
-        _ => compact_type.is_table()
+        _ => compact_type.is_table(),
     }
 }
 

…s/src/semantic/type_compact/func_type.rs …sis/src/semantic/type_check/func_type.rscrates/emmylua_code_analysis/src/semantic/type_compact/func_type.rs renamed to crates/emmylua_code_analysis/src/semantic/type_check/func_type.rs crates/emmylua_code_analysis/src/semantic/type_compact/func_type.rs renamed to crates/emmylua_code_analysis/src/semantic/type_check/func_type.rs

@@ -5,7 +5,7 @@ use emmylua_parser::{
 
 use crate::{DbIndex, Emmyrc, FileId, LuaMemberOwner, LuaPropertyOwnerId, LuaType};
 
-use super::{infer_expr, type_compact::is_sub_type_of, LuaInferConfig};
+use super::{infer_expr, type_check::is_sub_type_of, LuaInferConfig};
 
 pub fn check_visibility(
     db: &DbIndex,