fix clippy warning and error

Author: CppCXY

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

@@ -1,12 +1,10 @@
-use std::sync::Arc;
-
 use emmylua_parser::{LuaAstNode, LuaIndexKey, LuaIndexMemberExpr};
 use rowan::TextRange;
 use smol_str::SmolStr;
 
 use crate::{
-    InFiled, InferFailReason, LuaInferCache, LuaInstanceType, LuaMemberId, LuaMemberOwner,
-    LuaOperatorOwner, TypeOps, TypeSubstitutor, check_type_compact,
+    InFiled, InferFailReason, InferGuardRef, LuaInferCache, LuaInstanceType, LuaMemberId,
+    LuaMemberOwner, LuaOperatorOwner, TypeOps, TypeSubstitutor, check_type_compact,
     db_index::{
         DbIndex, LuaGenericType, LuaIntersectionType, LuaMemberKey, LuaObjectType,
         LuaOperatorMetaMethod, LuaTupleType, LuaType, LuaTypeDeclId, LuaUnionType,
@@ -112,7 +110,7 @@ fn find_function_type_by_member_key(
     cache: &mut LuaInferCache,
     prefix_type: &LuaType,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     match &prefix_type {
@@ -179,7 +177,7 @@ fn find_custom_type_function_member(
     cache: &mut LuaInferCache,
     prefix_type_id: LuaTypeDeclId,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     infer_guard.check(&prefix_type_id)?;
@@ -323,7 +321,7 @@ fn find_union_function_member(
     cache: &mut LuaInferCache,
     union_type: &LuaUnionType,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     let mut member_types = Vec::new();
@@ -352,7 +350,7 @@ fn index_generic_members_from_super_generics(
     type_decl_id: &LuaTypeDeclId,
     substitutor: &TypeSubstitutor,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> Option<LuaType> {
     let type_index = db.get_type_index();
@@ -386,7 +384,7 @@ fn find_generic_member(
     cache: &mut LuaInferCache,
     generic_type: &LuaGenericType,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     let base_type = generic_type.get_base_type();
@@ -425,7 +423,7 @@ fn find_instance_member_decl_type(
     cache: &mut LuaInferCache,
     inst: &LuaInstanceType,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     let origin_type = inst.get_base();
@@ -444,7 +442,7 @@ fn find_function_type_by_operator(
     cache: &mut LuaInferCache,
     prefix_type: &LuaType,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     match &prefix_type {
@@ -577,7 +575,7 @@ fn find_member_by_index_custom_type(
     cache: &mut LuaInferCache,
     prefix_type_id: &LuaTypeDeclId,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     infer_guard.check(prefix_type_id)?;
@@ -691,7 +689,7 @@ fn find_member_by_index_union(
     cache: &mut LuaInferCache,
     union: &LuaUnionType,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     let mut member_type = LuaType::Unknown;
@@ -727,7 +725,7 @@ fn find_member_by_index_intersection(
     cache: &mut LuaInferCache,
     intersection: &LuaIntersectionType,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     for member in intersection.get_types() {
@@ -755,7 +753,7 @@ fn find_member_by_index_generic(
     cache: &mut LuaInferCache,
     generic: &LuaGenericType,
     index_expr: LuaIndexMemberExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     deep_guard: &mut DeepLevel,
 ) -> FunctionTypeResult {
     let base_type = generic.get_base_type();

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

@@ -3,9 +3,9 @@ use std::sync::Arc;
 use emmylua_parser::{LuaAstNode, LuaIndexMemberExpr, LuaTableExpr, LuaVarExpr};
 
 use crate::{
-    DbIndex, InferFailReason, InferGuard, LuaDocParamInfo, LuaDocReturnInfo, LuaFunctionType,
-    LuaInferCache, LuaSignature, LuaType, SignatureReturnStatus, TypeOps, get_real_type,
-    infer_call_expr_func, infer_expr, infer_table_should_be,
+    DbIndex, InferFailReason, InferGuard, InferGuardRef, LuaDocParamInfo, LuaDocReturnInfo,
+    LuaFunctionType, LuaInferCache, LuaSignature, LuaType, SignatureReturnStatus, TypeOps,
+    get_real_type, infer_call_expr_func, infer_expr, infer_table_should_be,
 };
 
 use super::{
@@ -28,7 +28,7 @@ pub fn try_resolve_call_closure_params(
         cache,
         call_expr.clone(),
         call_expr_type,
-        &mut InferGuard::new(),
+        &InferGuard::new(),
         None,
     )?;
 
@@ -117,7 +117,7 @@ pub fn try_resolve_closure_return(
         cache,
         call_expr.clone(),
         call_expr_type,
-        &mut InferGuard::new(),
+        &InferGuard::new(),
         None,
     )?;
 
@@ -280,7 +280,7 @@ fn resolve_closure_member_type(
     closure_params: &UnResolveParentClosureParams,
     member_type: &LuaType,
     self_type: Option<LuaType>,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
 ) -> ResolveResult {
     match &member_type {
         LuaType::DocFunction(doc_func) => {

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

@@ -50,15 +50,15 @@ fn check_name_expr(
         .get_property_index()
         .get_property(&semantic_decl)?;
     if let Some(deprecated) = property.deprecated() {
-        let depreacated_message = match deprecated {
+        let deprecated_message = match deprecated {
             LuaDeprecated::Deprecated => "deprecated".to_string(),
             LuaDeprecated::DeprecatedWithMessage(message) => message.to_string(),
         };
 
         context.add_diagnostic(
             DiagnosticCode::Deprecated,
             name_expr.get_range(),
-            depreacated_message,
+            deprecated_message,
             None,
         );
     }
@@ -85,7 +85,7 @@ fn check_index_expr(
         .get_property_index()
         .get_property(&semantic_decl)?;
     if let Some(deprecated) = property.deprecated() {
-        let depreacated_message = match deprecated {
+        let deprecated_message = match deprecated {
             LuaDeprecated::Deprecated => "deprecated".to_string(),
             LuaDeprecated::DeprecatedWithMessage(message) => message.to_string(),
         };
@@ -95,7 +95,7 @@ fn check_index_expr(
         context.add_diagnostic(
             DiagnosticCode::Deprecated,
             index_name_range,
-            depreacated_message,
+            deprecated_message,
             None,
         );
     }

crates/emmylua_code_analysis/src/semantic/guard.rs

@@ -1,7 +1,9 @@
-use std::{cell::RefCell, collections::HashSet, sync::Arc};
+use std::{cell::RefCell, collections::HashSet, rc::Rc};
 
 use crate::{InferFailReason, LuaTypeDeclId};
 
+pub type InferGuardRef = Rc<InferGuard>;
+
 /// Guard to prevent infinite recursion
 /// Some type may reference itself, so we need to check if we have already inferred this type
 ///
@@ -12,27 +14,27 @@ pub struct InferGuard {
     /// Current level's visited types
     current: RefCell<HashSet<LuaTypeDeclId>>,
     /// Parent guard (shared reference)
-    parent: Option<Arc<InferGuard>>,
+    parent: Option<Rc<InferGuard>>,
 }
 
 impl InferGuard {
-    pub fn new() -> Arc<Self> {
-        Arc::new(Self {
+    pub fn new() -> Rc<Self> {
+        Rc::new(Self {
             current: RefCell::new(HashSet::default()),
             parent: None,
         })
     }
 
     /// Create a child guard that inherits from parent
     /// This allows branching while preventing infinite recursion across the entire call stack
-    pub fn fork(self: &Arc<Self>) -> Arc<Self> {
-        Arc::new(Self {
+    pub fn fork(self: &Rc<Self>) -> Rc<Self> {
+        Rc::new(Self {
             current: RefCell::new(HashSet::default()),
-            parent: Some(Arc::clone(self)),
+            parent: Some(Rc::clone(self)),
         })
     }
 
-    /// Create a child guard from a non-Arc guard
+    /// Create a child guard from a non-Rc guard
     /// This is a convenience method for when you have a stack-allocated guard
     pub fn fork_owned(&self) -> Self {
         Self {

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

@@ -11,13 +11,16 @@ use super::{
     },
     InferFailReason, InferResult,
 };
-use crate::semantic::{
-    generic::instantiate_doc_function, infer::narrow::get_type_at_call_expr_inline_cast,
-};
 use crate::{
     CacheEntry, DbIndex, InFiled, LuaFunctionType, LuaGenericType, LuaInstanceType,
     LuaOperatorMetaMethod, LuaOperatorOwner, LuaSignatureId, LuaType, LuaTypeDeclId, LuaUnionType,
 };
+use crate::{
+    InferGuardRef,
+    semantic::{
+        generic::instantiate_doc_function, infer::narrow::get_type_at_call_expr_inline_cast,
+    },
+};
 use crate::{build_self_type, infer_self_type, semantic::infer_expr};
 use infer_require::infer_require_call;
 use infer_setmetatable::infer_setmetatable_call;
@@ -32,7 +35,7 @@ pub fn infer_call_expr_func(
     cache: &mut LuaInferCache,
     call_expr: LuaCallExpr,
     call_expr_type: LuaType,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     args_count: Option<usize>,
 ) -> InferCallFuncResult {
     let syntax_id = call_expr.get_syntax_id();
@@ -216,7 +219,7 @@ fn infer_type_doc_function(
     type_id: LuaTypeDeclId,
     call_expr: LuaCallExpr,
     call_expr_type: &LuaType,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     args_count: Option<usize>,
 ) -> InferCallFuncResult {
     infer_guard.check(&type_id)?;
@@ -287,7 +290,7 @@ fn infer_generic_type_doc_function(
     cache: &mut LuaInferCache,
     generic: &LuaGenericType,
     call_expr: LuaCallExpr,
-    infer_guard: &Arc<InferGuard>,
+    infer_guard: &InferGuardRef,
     args_count: Option<usize>,
 ) -> InferCallFuncResult {
     let type_id = generic.get_base_type_id();
@@ -346,7 +349,7 @@ fn infer_generic_type_doc_function(
                 if let LuaType::DocFunction(f) = new_f {
                     overloads.push(f.clone());
                 }
-                // todo: support oveload?
+                // todo: support overload?
             }
             _ => {}
         }