optimize performance for large table

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/lua/stats.rs

@@ -441,35 +441,35 @@ pub fn analyze_local_func_stat(
 }
 
 pub fn analyze_table_field(analyzer: &mut LuaAnalyzer, field: LuaTableField) -> Option<()> {
-    let _ = field.get_field_key()?;
-    let value_expr = field.get_value_expr()?;
-    let member_id = LuaMemberId::new(field.get_syntax_id(), analyzer.file_id);
-    let value_type = match analyzer.infer_expr(&value_expr.clone().into()) {
-        Ok(value_type) => match value_type {
-            LuaType::Def(ref_id) => LuaType::Ref(ref_id),
-            _ => value_type,
-        },
-        Err(InferFailReason::None) => LuaType::Unknown,
-        Err(reason) => {
-            let unresolve = UnResolveMember {
-                file_id: analyzer.file_id,
-                member_id,
-                expr: Some(value_expr.clone()),
-                prefix: None,
-                ret_idx: 0,
-            };
-
-            analyzer.context.add_unresolve(unresolve.into(), reason);
-            return None;
-        }
-    };
+    if field.is_assign_field() {
+        let value_expr = field.get_value_expr()?;
+        let member_id = LuaMemberId::new(field.get_syntax_id(), analyzer.file_id);
+        let value_type = match analyzer.infer_expr(&value_expr.clone().into()) {
+            Ok(value_type) => match value_type {
+                LuaType::Def(ref_id) => LuaType::Ref(ref_id),
+                _ => value_type,
+            },
+            Err(InferFailReason::None) => LuaType::Unknown,
+            Err(reason) => {
+                let unresolve = UnResolveMember {
+                    file_id: analyzer.file_id,
+                    member_id,
+                    expr: Some(value_expr.clone()),
+                    prefix: None,
+                    ret_idx: 0,
+                };
 
-    bind_type(
-        analyzer.db,
-        member_id.into(),
-        LuaTypeCache::InferType(value_type),
-    );
+                analyzer.context.add_unresolve(unresolve.into(), reason);
+                return None;
+            }
+        };
 
+        bind_type(
+            analyzer.db,
+            member_id.into(),
+            LuaTypeCache::InferType(value_type),
+        );
+    }
     Some(())
 }
 

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

@@ -57,11 +57,28 @@ fn check_table_expr(
                 }
             }
         }
+        LuaType::TableConst(in_file_range) => {
+            let file_id = in_file_range.file_id;
+            if file_id == semantic_model.get_file_id() {
+                let range = in_file_range.value;
+                if expr.get_range() == range {
+                    return Some(());
+                }
+            }
+
+            LuaType::TableConst(in_file_range)
+        }
+
         table_type => table_type,
     };
 
-    let current_fields = expr
-        .get_fields()
+    let fields = expr.get_fields().collect::<Vec<_>>();
+    if fields.len() > 50 {
+        return Some(());
+    }
+
+    let current_fields = fields
+        .iter()
         .filter_map(|field| field.get_field_key().map(|key| key.get_path_part()))
         .collect();
 

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

@@ -41,8 +41,10 @@ use lsp_types::{Diagnostic, DiagnosticSeverity, DiagnosticTag, NumberOrString};
 use rowan::TextRange;
 use std::sync::Arc;
 
+#[allow(unused)]
 use crate::{
-    FileId, LuaType, RenderLevel, db_index::DbIndex, humanize_type, semantic::SemanticModel,
+    FileId, LuaType, Profile, RenderLevel, db_index::DbIndex, humanize_type,
+    semantic::SemanticModel,
 };
 
 use super::{
@@ -62,6 +64,9 @@ fn run_check<T: Checker>(context: &mut DiagnosticContext, semantic_model: &Seman
         .iter()
         .any(|code| context.is_checker_enable_by_code(code))
     {
+        // let name = T::CODES.iter().map(|c| c.get_name()).collect::<Vec<_>>().join(",");
+        // let show_name = format!("{}({})", std::any::type_name::<T>(), name);
+        // let _p = Profile::new(&show_name);
         T::check(context, semantic_model);
     }
 }