optimize type check performance

Author: CppCXY

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

@@ -38,7 +38,7 @@ fn check_assign_stat(
 ) -> Option<()> {
     let (vars, exprs) = assign.get_var_and_expr_list();
     let value_types =
-        semantic_model.infer_multi_value_adjusted_expression_types(&exprs, Some(vars.len()))?;
+        semantic_model.infer_multi_value_adjusted_expression_types(&exprs, Some(vars.len()));
 
     for (idx, var) in vars.iter().enumerate() {
         match var {
@@ -113,6 +113,7 @@ fn check_name_expr(
     if let Some(expr) = expr {
         handle_value_is_table_expr(context, semantic_model, origin_type, &expr);
     }
+
     Some(())
 }
 
@@ -169,8 +170,8 @@ fn check_local_stat(
 ) -> Option<()> {
     let vars = local.get_local_name_list().collect::<Vec<_>>();
     let value_exprs = local.get_value_exprs().collect::<Vec<_>>();
-    let value_types = semantic_model
-        .infer_multi_value_adjusted_expression_types(&value_exprs, Some(vars.len()))?;
+    let value_types =
+        semantic_model.infer_multi_value_adjusted_expression_types(&value_exprs, Some(vars.len()));
 
     for (idx, var) in vars.iter().enumerate() {
         let name_token = var.get_name_token()?;
@@ -208,20 +209,29 @@ fn handle_value_is_table_expr(
     value_expr: &LuaExpr,
 ) -> Option<()> {
     let table_type = table_type?;
-    let member_infos = semantic_model.infer_member_infos(&table_type)?;
-    let fields = LuaTableExpr::cast(value_expr.syntax().clone())?.get_fields();
+    let fields = LuaTableExpr::cast(value_expr.syntax().clone())?
+        .get_fields()
+        .collect::<Vec<_>>();
+    if fields.len() > 50 {
+        // 如果字段过多, 则不进行类型检查
+        return Some(());
+    }
+
     for field in fields {
         if field.is_value_field() {
             continue;
         }
 
         let field_key = field.get_field_key();
         if let Some(field_key) = field_key {
-            let field_path_part = field_key.get_path_part();
-            let source_type = member_infos
-                .iter()
-                .find(|info| info.key.to_path() == field_path_part)
-                .map(|info| info.typ.clone());
+            let member_key = semantic_model.get_member_key(&field_key)?;
+            let source_type = match semantic_model.infer_member_type(&table_type, &member_key) {
+                Ok(typ) => Some(typ),
+                Err(_) => {
+                    continue;
+                }
+            };
+
             let expr = field.get_value_expr();
             if let Some(expr) = expr {
                 let expr_type = semantic_model.infer_expr(expr).unwrap_or(LuaType::Any);

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

@@ -207,7 +207,7 @@ fn is_valid_member(
 
     let prefix_types = get_prefix_types(prefix_typ);
     for prefix_type in prefix_types {
-        if let Some(members) = semantic_model.infer_member_infos(&prefix_type) {
+        if let Some(members) = semantic_model.get_member_infos(&prefix_type) {
             for info in &members {
                 match &info.key {
                     LuaMemberKey::Expr(typ) => {

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

@@ -24,14 +24,19 @@ fn check_table_duplicate_index(
     _: &SemanticModel,
     table: LuaTableExpr,
 ) -> Option<()> {
-    let fields = table.get_fields();
+    let fields = table.get_fields().collect::<Vec<_>>();
+    if fields.len() > 50 {
+        // Skip checking if there are too many fields to avoid performance issues
+        return Some(());
+    }
+
     let mut index_map: HashMap<String, Vec<LuaIndexKey>> = HashMap::new();
 
     for field in fields {
         let key = field.get_field_key();
         if let Some(key) = key {
             index_map
-                .entry(key.get_path_part().to_string())
+                .entry(key.get_path_part())
                 .or_insert_with(Vec::new)
                 .push(key);
         }

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

@@ -39,7 +39,7 @@ fn check_call_expr(
     let mut params = func.get_params().to_vec();
     let arg_exprs: Vec<LuaExpr> = call_expr.get_args_list()?.get_args().collect::<Vec<_>>();
     let (mut arg_types, mut arg_ranges) = {
-        let infos = semantic_model.infer_multi_value_adjusted_expression_types(&arg_exprs, None)?;
+        let infos = semantic_model.infer_multi_value_adjusted_expression_types(&arg_exprs, None);
         let arg_types = infos.iter().map(|(typ, _)| typ.clone()).collect::<Vec<_>>();
         let arg_ranges = infos
             .iter()

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

@@ -58,7 +58,7 @@ fn check_return_stat(
         let infos = semantic_model.infer_multi_value_adjusted_expression_types(
             &return_stat.get_expr_list().collect::<Vec<_>>(),
             None,
-        )?;
+        );
         let mut return_expr_types = infos.iter().map(|(typ, _)| typ.clone()).collect::<Vec<_>>();
         // 解决 setmetatable 的返回值类型问题
         let setmetatable_index = has_setmetatable(semantic_model, return_stat);

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

@@ -59,8 +59,8 @@ fn check_unbalanced_assignment(
         return Some(());
     }
 
-    let value_types = semantic_model
-        .infer_multi_value_adjusted_expression_types(value_exprs, Some(vars.len()))?;
+    let value_types =
+        semantic_model.infer_multi_value_adjusted_expression_types(value_exprs, Some(vars.len()));
     if let Some(last_type) = value_types.last() {
         if check_last(&last_type.0) {
             return Some(());

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

@@ -77,18 +77,14 @@ fn infer_member_type_pass_flow(
             return Ok(member_type.clone());
         }
         LuaType::Ref(decl_id) => {
-            if let Some(members) = db
-                .get_member_index()
-                .get_members(&LuaMemberOwner::Type(decl_id.clone()))
+            let index_key = index_expr.get_index_key().ok_or(InferFailReason::None)?;
+            let key = LuaMemberKey::from_index_key(db, cache, &index_key)?;
+            let member_index = db.get_member_index();
+            if member_index
+                .get_member_item(&LuaMemberOwner::Type(decl_id.clone()), &key)
+                .is_some()
             {
-                if let Some(key) = index_expr.get_index_key() {
-                    if let Some(_) = members
-                        .iter()
-                        .find(|m| m.get_key().to_path() == key.get_path_part())
-                    {
-                        allow_reassign = false
-                    }
-                }
+                allow_reassign = false;
             }
         }
         _ => {}

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

@@ -29,10 +29,10 @@ use smol_str::SmolStr;
 
 use crate::{
     db_index::{DbIndex, LuaOperator, LuaOperatorMetaMethod, LuaSignatureId, LuaType},
-    InFiled, VariadicType,
+    InFiled, LuaMemberKey, VariadicType,
 };
 
-use super::{member::find_members, CacheEntry, CacheKey, LuaInferCache};
+use super::{member::infer_raw_member_type, CacheEntry, CacheKey, LuaInferCache};
 
 pub type InferResult = Result<LuaType, InferFailReason>;
 pub use infer_call::InferCallFuncResult;
@@ -175,24 +175,24 @@ pub fn infer_multi_value_adjusted_expression_types(
     cache: &mut LuaInferCache,
     exprs: &[LuaExpr],
     var_count: Option<usize>,
-) -> Option<Vec<(LuaType, TextRange)>> {
+) -> Vec<(LuaType, TextRange)> {
     let mut value_types = Vec::new();
     for (idx, expr) in exprs.iter().enumerate() {
-        let expr_type = infer_expr(db, cache, expr.clone()).ok()?;
+        let expr_type = infer_expr(db, cache, expr.clone()).unwrap_or(LuaType::Unknown);
         match expr_type {
-            LuaType::Variadic(multi) => {
+            LuaType::Variadic(variadic) => {
                 if let Some(var_count) = var_count {
                     if idx < var_count {
                         for i in idx..var_count {
-                            if let Some(typ) = multi.get_type(i - idx) {
+                            if let Some(typ) = variadic.get_type(i - idx) {
                                 value_types.push((typ.clone(), expr.get_range()));
                             } else {
                                 break;
                             }
                         }
                     }
                 } else {
-                    match multi.deref() {
+                    match variadic.deref() {
                         VariadicType::Base(base) => {
                             value_types.push((base.clone(), expr.get_range()));
                         }
@@ -210,7 +210,7 @@ pub fn infer_multi_value_adjusted_expression_types(
         }
     }
 
-    Some(value_types)
+    value_types
 }
 
 /// 从右值推断左值已绑定的类型
@@ -254,14 +254,15 @@ pub fn infer_left_value_type_from_right_value(
             let field_key = table_field.get_field_key()?;
             let table_expr = table_field.get_parent::<LuaTableExpr>()?;
             let table_type = infer_table_should_be(db, cache, table_expr.clone()).ok()?;
-            let member_infos = find_members(db, &table_type)?;
-            let mut typ = None;
-            for member_info in member_infos.iter() {
-                if member_info.key.to_path() == field_key.get_path_part() {
-                    typ = Some(member_info.typ.clone());
-                }
+            let member_key = match LuaMemberKey::from_index_key(db, cache, &field_key) {
+                Ok(key) => key,
+                Err(_) => return None,
+            };
+            match infer_raw_member_type(db, &table_type, &member_key) {
+                Ok(typ) => Some(typ),
+                Err(InferFailReason::FieldNotFound) => None,
+                Err(_) => Some(LuaType::Unknown),
             }
-            typ
         }
         _ => None,
     };

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -111,11 +111,11 @@ impl<'a> SemanticModel<'a> {
         infer_table_should_be(self.db, &mut self.infer_cache.borrow_mut(), table).ok()
     }
 
-    pub fn infer_member_infos(&self, prefix_type: &LuaType) -> Option<Vec<LuaMemberInfo>> {
+    pub fn get_member_infos(&self, prefix_type: &LuaType) -> Option<Vec<LuaMemberInfo>> {
         find_members(self.db, prefix_type)
     }
 
-    pub fn get_member_map(
+    pub fn get_member_info_map(
         &self,
         prefix_type: &LuaType,
     ) -> Option<HashMap<LuaMemberKey, Vec<LuaMemberInfo>>> {
@@ -154,7 +154,7 @@ impl<'a> SemanticModel<'a> {
         &self,
         exprs: &[LuaExpr],
         var_count: Option<usize>,
-    ) -> Option<Vec<(LuaType, TextRange)>> {
+    ) -> Vec<(LuaType, TextRange)> {
         infer_multi_value_adjusted_expression_types(
             self.db,
             &mut self.infer_cache.borrow_mut(),
@@ -269,6 +269,14 @@ impl<'a> SemanticModel<'a> {
     pub fn get_member_key(&self, index_key: &LuaIndexKey) -> Option<LuaMemberKey> {
         LuaMemberKey::from_index_key(self.db, &mut self.infer_cache.borrow_mut(), index_key).ok()
     }
+
+    pub fn infer_member_type(
+        &self,
+        prefix_type: &LuaType,
+        member_key: &LuaMemberKey,
+    ) -> Result<LuaType, InferFailReason> {
+        member::infer_raw_member_type(self.db, prefix_type, member_key)
+    }
 }
 
 /// Guard to prevent infinite recursion

crates/emmylua_ls/src/handlers/completion/providers/member_provider.rs

@@ -25,7 +25,7 @@ pub fn add_completion(builder: &mut CompletionBuilder) -> Option<()> {
 
     let prefix_expr = index_expr.get_prefix_expr()?;
     let prefix_type = builder.semantic_model.infer_expr(prefix_expr.into()).ok()?;
-    let member_info_map = builder.semantic_model.get_member_map(&prefix_type)?;
+    let member_info_map = builder.semantic_model.get_member_info_map(&prefix_type)?;
     for (_, member_infos) in member_info_map.iter() {
         add_resolve_member_infos(builder, &member_infos, completion_status);
     }