more fast resolve

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/doc/type_ref_tags.rs

@@ -10,7 +10,8 @@ use crate::{
         LuaDeclId, LuaDocParamInfo, LuaDocReturnInfo, LuaMemberId, LuaOperator, LuaSemanticDeclId,
         LuaSignatureId, LuaType,
     },
-    InFiled, LuaOperatorMetaMethod, LuaTypeCache, OperatorFunction, SignatureReturnStatus, TypeOps,
+    InFiled, InferFailReason, LuaOperatorMetaMethod, LuaTypeCache, OperatorFunction,
+    SignatureReturnStatus, TypeOps,
 };
 
 use super::{
@@ -240,6 +241,7 @@ pub fn analyze_module(analyzer: &mut DocAnalyzer, tag: LuaDocTagModule) -> Optio
         let unresolve = UnResolveModuleRef {
             module_file_id,
             owner_id,
+            reason: InferFailReason::None,
         };
 
         analyzer.context.add_unresolve(unresolve.into());

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

@@ -62,6 +62,7 @@ fn analyze_lambda_params(
                 signature_id: signature_id.clone(),
                 call_expr,
                 param_idx: founded_idx,
+                reason: InferFailReason::None,
             };
 
             analyzer.add_unresolved(unresolved.into());
@@ -71,6 +72,7 @@ fn analyze_lambda_params(
                 file_id: analyzer.file_id,
                 signature_id: signature_id.clone(),
                 parent_ast: UnResolveParentAst::LuaFuncStat(func_stat.clone()),
+                reason: InferFailReason::None,
             };
 
             analyzer.add_unresolved(unresolved.into());
@@ -80,6 +82,7 @@ fn analyze_lambda_params(
                 file_id: analyzer.file_id,
                 signature_id: signature_id.clone(),
                 parent_ast: UnResolveParentAst::LuaTableField(table_field.clone()),
+                reason: InferFailReason::None,
             };
 
             analyzer.add_unresolved(unresolved.into());
@@ -89,6 +92,7 @@ fn analyze_lambda_params(
                 file_id: analyzer.file_id,
                 signature_id: signature_id.clone(),
                 parent_ast: UnResolveParentAst::LuaAssignStat(assign_stat.clone()),
+                reason: InferFailReason::None,
             };
 
             analyzer.add_unresolved(unresolved.into());
@@ -181,6 +185,7 @@ fn analyze_lambda_returns(
         call_expr,
         param_idx: founded_idx,
         return_points,
+        reason: InferFailReason::None,
     };
 
     analyzer.add_unresolved(unresolved.into());

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

@@ -1,9 +1,8 @@
 use emmylua_parser::LuaAstNode;
 
 use crate::{
-    infer_expr, DbIndex, FileId, InFiled, InferFailReason, LuaDeclExtra, LuaDeclId,
-    LuaDocParamInfo, LuaDocReturnInfo, LuaInferCache, LuaSemanticDeclId, LuaType, LuaTypeCache,
-    SignatureReturnStatus,
+    infer_expr, DbIndex, FileId, InFiled, InferFailReason, LuaDocReturnInfo, LuaInferCache,
+    LuaSemanticDeclId, LuaType, LuaTypeCache, SignatureReturnStatus,
 };
 
 use super::{infer_manager::InferCacheManager, UnResolve};
@@ -44,53 +43,68 @@ pub fn check_reach_reason(
     }
 }
 
-pub fn resolve_all_reason<F>(
+pub fn resolve_all_reason(
     db: &mut DbIndex,
     infer_manager: &mut InferCacheManager,
     unresolves: &mut Vec<UnResolve>,
-    resolve_fn: F,
-) where
-    F: Fn(&mut DbIndex, &mut LuaInferCache, &mut InferFailReason) -> Option<()>,
-{
+) {
     for unresolve in unresolves.iter_mut() {
         let file_id = unresolve.get_file_id().unwrap_or(FileId { id: 0 });
         let cache = infer_manager.get_infer_cache(file_id);
+        let mut need_remove = Some(false);
         match unresolve {
             UnResolve::Decl(un_resolve_decl) => {
-                resolve_fn(db, cache, &mut un_resolve_decl.reason);
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_decl.reason);
             }
             UnResolve::Member(ref mut un_resolve_member) => {
-                resolve_fn(db, cache, &mut un_resolve_member.reason);
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_member.reason);
             }
             UnResolve::Module(un_resolve_module) => {
-                resolve_fn(db, cache, &mut un_resolve_module.reason);
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_module.reason);
             }
             UnResolve::Return(un_resolve_return) => {
-                resolve_fn(db, cache, &mut un_resolve_return.reason);
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_return.reason);
             }
             UnResolve::IterDecl(un_resolve_iter_var) => {
-                resolve_fn(db, cache, &mut un_resolve_iter_var.reason);
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_iter_var.reason);
             }
-            _ => continue,
+            UnResolve::ClosureParams(un_resolve_call_closure_params) => {
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_call_closure_params.reason);
+            }
+            UnResolve::ClosureReturn(un_resolve_closure_return) => {
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_closure_return.reason);
+            }
+            UnResolve::ClosureParentParams(un_resolve_parent_closure_params) => {
+                need_remove =
+                    resolve_as_any(db, cache, &mut un_resolve_parent_closure_params.reason);
+            }
+            UnResolve::ModuleRef(un_resolve_module_ref) => {
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_module_ref.reason);
+            }
+            UnResolve::TableField(un_resolve_table_field) => {
+                need_remove = resolve_as_any(db, cache, &mut un_resolve_table_field.reason);
+            }
+            UnResolve::None => {}
         };
+
+        if need_remove.unwrap_or(false) {
+            *unresolve = UnResolve::None;
+        }
     }
 }
 
 pub fn resolve_as_any(
     db: &mut DbIndex,
     cache: &mut LuaInferCache,
     reason: &mut InferFailReason,
-) -> Option<()> {
+) -> Option<bool> {
     match reason {
         InferFailReason::None
         | InferFailReason::FieldDotFound
-        | InferFailReason::RecursiveInfer => {}
+        | InferFailReason::RecursiveInfer => {
+            return Some(true);
+        }
         InferFailReason::UnResolveDeclType(decl_id) => {
-            let decl = db.get_decl_index_mut().get_decl_mut(decl_id)?;
-            if decl.is_param() {
-                return set_param_decl_type(db, decl_id, LuaType::Any);
-            }
-
             db.get_type_index_mut().bind_type(
                 decl_id.clone().into(),
                 LuaTypeCache::InferType(LuaType::Any),
@@ -128,33 +142,33 @@ pub fn resolve_as_any(
     }
 
     *reason = InferFailReason::None;
-    Some(())
+    Some(false)
 }
 
-fn set_param_decl_type(db: &mut DbIndex, decl_id: &LuaDeclId, typ: LuaType) -> Option<()> {
-    let decl = db.get_decl_index_mut().get_decl_mut(decl_id)?;
+// fn set_param_decl_type(db: &mut DbIndex, decl_id: &LuaDeclId, typ: LuaType) -> Option<()> {
+//     let decl = db.get_decl_index_mut().get_decl_mut(decl_id)?;
 
-    let (param_idx, signature_id) = match &decl.extra {
-        LuaDeclExtra::Param {
-            idx, signature_id, ..
-        } => (*idx, *signature_id),
-        _ => unreachable!(),
-    };
+//     let (param_idx, signature_id) = match &decl.extra {
+//         LuaDeclExtra::Param {
+//             idx, signature_id, ..
+//         } => (*idx, *signature_id),
+//         _ => unreachable!(),
+//     };
 
-    // find local annotation
-    if let Some(signature) = db.get_signature_index_mut().get_mut(&signature_id) {
-        if signature.param_docs.get(&param_idx).is_none() {
-            let name = signature.params.get(param_idx)?;
-            signature.param_docs.insert(
-                param_idx,
-                LuaDocParamInfo {
-                    name: name.clone(),
-                    type_ref: typ,
-                    description: None,
-                    nullable: false,
-                },
-            );
-        }
-    }
-    Some(())
-}
+//     // find local annotation
+//     if let Some(signature) = db.get_signature_index_mut().get_mut(&signature_id) {
+//         if signature.param_docs.get(&param_idx).is_none() {
+//             let name = signature.params.get(param_idx)?;
+//             signature.param_docs.insert(
+//                 param_idx,
+//                 LuaDocParamInfo {
+//                     name: name.clone(),
+//                     type_ref: typ,
+//                     description: None,
+//                     nullable: false,
+//                 },
+//             );
+//         }
+//     }
+//     Some(())
+// }

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

@@ -8,7 +8,7 @@ use crate::{
     profile::Profile,
     FileId, InferFailReason, LuaMemberFeature, LuaSemanticDeclId,
 };
-use check_reason::{resolve_all_reason, resolve_as_any};
+use check_reason::resolve_all_reason;
 use emmylua_parser::{
     LuaAssignStat, LuaCallExpr, LuaExpr, LuaFuncStat, LuaTableExpr, LuaTableField,
 };
@@ -27,24 +27,20 @@ pub fn analyze(db: &mut DbIndex, context: &mut AnalyzeContext) {
     let _p = Profile::cond_new("resolve analyze", context.tree_list.len() > 1);
     let mut unresolves = std::mem::take(&mut context.unresolves);
     let mut infer_manager = InferCacheManager::new();
-    while try_resolve(db, &mut infer_manager, &mut unresolves) {
-        unresolves.retain(|un_resolve| match un_resolve {
-            UnResolve::None => false,
-            _ => true,
-        });
-    }
 
-    infer_manager.set_force();
     let mut loop_count = 0;
     while !unresolves.is_empty() {
-        resolve_all_reason(db, &mut infer_manager, &mut unresolves, resolve_as_any);
-
         while try_resolve(db, &mut infer_manager, &mut unresolves) {
             unresolves.retain(|un_resolve| match un_resolve {
                 UnResolve::None => false,
                 _ => true,
             });
         }
+        if loop_count == 0 {
+            infer_manager.set_force();
+        }
+
+        resolve_all_reason(db, &mut infer_manager, &mut unresolves);
 
         if loop_count >= 10 {
             break;
@@ -215,6 +211,7 @@ pub struct UnResolveCallClosureParams {
     pub signature_id: LuaSignatureId,
     pub call_expr: LuaCallExpr,
     pub param_idx: usize,
+    pub reason: InferFailReason,
 }
 
 impl From<UnResolveCallClosureParams> for UnResolve {
@@ -245,6 +242,7 @@ pub struct UnResolveClosureReturn {
     pub call_expr: LuaCallExpr,
     pub param_idx: usize,
     pub return_points: Vec<LuaReturnPoint>,
+    pub reason: InferFailReason,
 }
 
 impl From<UnResolveClosureReturn> for UnResolve {
@@ -257,6 +255,7 @@ impl From<UnResolveClosureReturn> for UnResolve {
 pub struct UnResolveModuleRef {
     pub owner_id: LuaSemanticDeclId,
     pub module_file_id: FileId,
+    pub reason: InferFailReason,
 }
 
 impl From<UnResolveModuleRef> for UnResolve {
@@ -277,6 +276,7 @@ pub struct UnResolveParentClosureParams {
     pub file_id: FileId,
     pub signature_id: LuaSignatureId,
     pub parent_ast: UnResolveParentAst,
+    pub reason: InferFailReason,
 }
 
 impl From<UnResolveParentClosureParams> for UnResolve {

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

@@ -298,9 +298,13 @@ pub fn try_resolve_iter_var(
 
 pub fn try_resolve_module_ref(
     db: &mut DbIndex,
-    _: &mut LuaInferCache,
+    cache: &mut LuaInferCache,
     module_ref: &UnResolveModuleRef,
 ) -> Option<bool> {
+    if !check_reach_reason(db, cache, &module_ref.reason).unwrap_or(false) {
+        return None;
+    }
+
     let module_index = db.get_module_index();
     let module = module_index.get_module(module_ref.module_file_id)?;
     let export_type = module.export_type.clone()?;