Merge pull request #773 from ribru17/more_clippy

refactor: address all lint warnings in `emmylua_code_analysis`

Author: CppCXY

crates/emmylua_check/src/output/json_output_writer.rs

@@ -20,10 +20,10 @@ impl JsonOutputWriter {
         let output = match output {
             OutputDestination::Stdout => None,
             OutputDestination::File(path) => {
-                if let Some(parent) = path.parent() {
-                    if !parent.exists() {
-                        std::fs::create_dir_all(parent).unwrap();
-                    }
+                if let Some(parent) = path.parent()
+                    && !parent.exists()
+                {
+                    std::fs::create_dir_all(parent).unwrap();
                 }
 
                 Some(std::fs::File::create(path).unwrap())

crates/emmylua_check/src/output/sarif_output_writer.rs

@@ -23,10 +23,10 @@ impl SarifOutputWriter {
         let output = match output {
             OutputDestination::Stdout => None,
             OutputDestination::File(path) => {
-                if let Some(parent) = path.parent() {
-                    if !parent.exists() {
-                        std::fs::create_dir_all(parent).unwrap();
-                    }
+                if let Some(parent) = path.parent()
+                    && !parent.exists()
+                {
+                    std::fs::create_dir_all(parent).unwrap();
                 }
                 Some(std::fs::File::create(path).unwrap())
             }
@@ -115,7 +115,7 @@ impl OutputWriter for SarifOutputWriter {
         }
 
         let file_path = db.get_vfs().get_file_path(&file_id).unwrap();
-        let file_uri = file_path_to_uri(&file_path).unwrap().as_str().to_string();
+        let file_uri = file_path_to_uri(file_path).unwrap().as_str().to_string();
         self.ensure_tool();
 
         for diagnostic in diagnostics {

crates/emmylua_check/src/terminal_display/display.rs

@@ -395,12 +395,10 @@ impl TerminalDisplay {
             } else {
                 println!("\nCheck completed with warnings");
             }
+        } else if self.supports_color {
+            println!("\n{}", Color::Green.bold().paint("Check successful"));
         } else {
-            if self.supports_color {
-                println!("\n{}", Color::Green.bold().paint("Check successful"));
-            } else {
-                println!("\nCheck successful");
-            }
+            println!("\nCheck successful");
         }
     }
 }

crates/emmylua_code_analysis/src/compilation/analyzer/common/migrate_global_member.rs

@@ -24,10 +24,10 @@ fn migrate_global_member_to_decl(db: &mut DbIndex, decl_id: LuaDeclId) -> Option
         return None;
     }
 
-    let owner_id = get_owner_id(db, &decl_id.clone().into())?;
+    let owner_id = get_owner_id(db, &decl_id.into())?;
 
     let name = decl.get_name();
-    let global_id = GlobalId::new(name.into());
+    let global_id = GlobalId::new(name);
     let members = db
         .get_member_index()
         .get_members(&LuaMemberOwner::GlobalPath(global_id))?
@@ -47,7 +47,7 @@ fn migrate_global_member_to_decl(db: &mut DbIndex, decl_id: LuaDeclId) -> Option
 fn migrate_global_member_to_member(db: &mut DbIndex, member_id: LuaMemberId) -> Option<()> {
     let member = db.get_member_index().get_member(&member_id)?;
     let global_id = member.get_global_id()?;
-    let owner_id = get_owner_id(db, &member_id.clone().into())?;
+    let owner_id = get_owner_id(db, &member_id.into())?;
 
     let members = db
         .get_member_index()

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

@@ -16,30 +16,19 @@ pub fn bind_type(
 
     if decl_type_cache.is_none() {
         // type backward
-        if type_cache.is_infer() {
-            if let LuaTypeOwner::Decl(decl_id) = &type_owner {
-                if let Some(decl_ref) = db
-                    .get_reference_index()
-                    .get_decl_references(&decl_id.file_id, decl_id)
-                {
-                    if decl_ref.mutable {
-                        match &type_cache.as_type() {
-                            LuaType::IntegerConst(_) => {
-                                type_cache = LuaTypeCache::InferType(LuaType::Integer)
-                            }
-                            LuaType::StringConst(_) => {
-                                type_cache = LuaTypeCache::InferType(LuaType::String)
-                            }
-                            LuaType::BooleanConst(_) => {
-                                type_cache = LuaTypeCache::InferType(LuaType::Boolean)
-                            }
-                            LuaType::FloatConst(_) => {
-                                type_cache = LuaTypeCache::InferType(LuaType::Number)
-                            }
-                            _ => {}
-                        }
-                    }
-                }
+        if type_cache.is_infer()
+            && let LuaTypeOwner::Decl(decl_id) = &type_owner
+            && let Some(decl_ref) = db
+                .get_reference_index()
+                .get_decl_references(&decl_id.file_id, decl_id)
+            && decl_ref.mutable
+        {
+            match &type_cache.as_type() {
+                LuaType::IntegerConst(_) => type_cache = LuaTypeCache::InferType(LuaType::Integer),
+                LuaType::StringConst(_) => type_cache = LuaTypeCache::InferType(LuaType::String),
+                LuaType::BooleanConst(_) => type_cache = LuaTypeCache::InferType(LuaType::Boolean),
+                LuaType::FloatConst(_) => type_cache = LuaTypeCache::InferType(LuaType::Number),
+                _ => {}
             }
         }
 
@@ -59,8 +48,8 @@ fn merge_def_type(db: &mut DbIndex, decl_type: LuaType, expr_type: LuaType, merg
         return;
     }
 
-    match &decl_type {
-        LuaType::Def(def) => match &expr_type {
+    if let LuaType::Def(def) = &decl_type {
+        match &expr_type {
             LuaType::TableConst(in_filed_range) => {
                 merge_def_type_with_table(db, def.clone(), in_filed_range.clone());
             }
@@ -69,8 +58,7 @@ fn merge_def_type(db: &mut DbIndex, decl_type: LuaType, expr_type: LuaType, merg
                 merge_def_type(db, base_ref.clone(), expr_type, merge_level + 1);
             }
             _ => {}
-        },
-        _ => {}
+        }
     }
 }
 
@@ -104,7 +92,7 @@ pub fn add_member(db: &mut DbIndex, owner: LuaMemberOwner, member_id: LuaMemberI
 }
 
 fn get_owner_id(db: &DbIndex, type_owner: &LuaTypeOwner) -> Option<LuaMemberOwner> {
-    let type_cache = db.get_type_index().get_type_cache(&type_owner)?;
+    let type_cache = db.get_type_index().get_type_cache(type_owner)?;
     match type_cache.as_type() {
         LuaType::Ref(type_id) => Some(LuaMemberOwner::Type(type_id.clone())),
         LuaType::TableConst(id) => Some(LuaMemberOwner::Element(id.clone())),

crates/emmylua_code_analysis/src/compilation/analyzer/decl/exprs.rs

@@ -22,7 +22,7 @@ pub fn analyze_name_expr(analyzer: &mut DeclAnalyzer, expr: LuaNameExpr) -> Opti
     let decl_id = LuaDeclId::new(file_id, position);
     let (decl_id, is_local) = if analyzer.decl.get_decl(&decl_id).is_some() {
         (Some(decl_id), false)
-    } else if let Some(decl) = analyzer.find_decl(&name, position) {
+    } else if let Some(decl) = analyzer.find_decl(name, position) {
         if decl.is_local() {
             // reference local variable
             (Some(decl.get_id()), true)
@@ -197,7 +197,7 @@ fn analyze_closure_params(
     let signature = analyzer
         .db
         .get_signature_index_mut()
-        .get_or_create(signature_id.clone());
+        .get_or_create(*signature_id);
     let params = closure.get_params_list()?.get_params();
     for param in params {
         let name = if let Some(name_token) = param.get_name_token() {
@@ -306,7 +306,7 @@ pub fn analyze_literal_expr(analyzer: &mut DeclAnalyzer, expr: LuaLiteralExpr) -
                 .map(|_| decl_id)
                 .or_else(|| {
                     analyzer
-                        .find_decl(&dots_token.get_text(), position)
+                        .find_decl(dots_token.get_text(), position)
                         .and_then(|decl| decl.is_local().then(|| decl.get_id()))
                 });
 
@@ -326,17 +326,17 @@ pub fn analyze_literal_expr(analyzer: &mut DeclAnalyzer, expr: LuaLiteralExpr) -
 pub fn analyze_call_expr(analyzer: &mut DeclAnalyzer, expr: LuaCallExpr) -> Option<()> {
     if expr.is_require() {
         let args = expr.get_args_list()?;
-        if let Some(LuaExpr::LiteralExpr(literal_expr)) = args.get_args().next() {
-            if let Some(LuaLiteralToken::String(string_token)) = literal_expr.get_literal() {
-                let module_path = string_token.get_value();
-                let file_id = analyzer.get_file_id();
-                let module_info = analyzer.db.get_module_index().find_module(&module_path)?;
-                let module_file_id = module_info.file_id;
-                analyzer
-                    .db
-                    .get_file_dependencies_index_mut()
-                    .add_required_file(file_id, module_file_id);
-            }
+        if let Some(LuaExpr::LiteralExpr(literal_expr)) = args.get_args().next()
+            && let Some(LuaLiteralToken::String(string_token)) = literal_expr.get_literal()
+        {
+            let module_path = string_token.get_value();
+            let file_id = analyzer.get_file_id();
+            let module_info = analyzer.db.get_module_index().find_module(&module_path)?;
+            let module_file_id = module_info.file_id;
+            analyzer
+                .db
+                .get_file_dependencies_index_mut()
+                .add_required_file(file_id, module_file_id);
         }
     }
 

crates/emmylua_code_analysis/src/compilation/analyzer/decl/members.rs

@@ -54,13 +54,11 @@ pub fn find_index_owner(
                 }
                 _ => {}
             }
-        } else {
-            if let Some(access_path) = index_expr.get_access_path() {
-                return (
-                    LuaMemberOwner::LocalUnresolve,
-                    Some(GlobalId(SmolStr::new(access_path).into())),
-                );
-            }
+        } else if let Some(access_path) = index_expr.get_access_path() {
+            return (
+                LuaMemberOwner::LocalUnresolve,
+                Some(GlobalId(SmolStr::new(access_path).into())),
+            );
         }
     }
 

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

@@ -37,18 +37,14 @@ pub fn analyze_local_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalStat) -> Op
 
         let file_id = analyzer.get_file_id();
         let range = local_name.get_range();
-        let expr_id = if let Some(expr) = value_expr_list.get(index) {
-            Some(expr.get_syntax_id())
-        } else {
-            None
-        };
+        let expr_id = value_expr_list.get(index).map(|expr| expr.get_syntax_id());
 
         let decl = LuaDecl::new(
             &name,
             file_id,
             range,
             LuaDeclExtra::Local {
-                kind: local_name.syntax().kind().into(),
+                kind: local_name.syntax().kind(),
                 attrib,
             },
             expr_id,
@@ -62,11 +58,7 @@ pub fn analyze_local_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalStat) -> Op
 pub fn analyze_assign_stat(analyzer: &mut DeclAnalyzer, stat: LuaAssignStat) -> Option<()> {
     let (vars, value_exprs) = stat.get_var_and_expr_list();
     for (idx, var) in vars.iter().enumerate() {
-        let value_expr_id = if let Some(expr) = value_exprs.get(idx) {
-            Some(expr.get_syntax_id())
-        } else {
-            None
-        };
+        let value_expr_id = value_exprs.get(idx).map(|expr| expr.get_syntax_id());
 
         match &var {
             LuaVarExpr::NameExpr(name_expr) => {
@@ -91,7 +83,7 @@ pub fn analyze_assign_stat(analyzer: &mut DeclAnalyzer, stat: LuaAssignStat) ->
                     continue;
                 }
 
-                if let Some(decl) = analyzer.find_decl(&name, position) {
+                if let Some(decl) = analyzer.find_decl(name, position) {
                     let decl_id = decl.get_id();
                     analyzer
                         .db
@@ -136,7 +128,7 @@ pub fn analyze_assign_stat(analyzer: &mut DeclAnalyzer, stat: LuaAssignStat) ->
 
                 analyzer.db.get_member_index_mut().add_member(owner, member);
                 if let LuaMemberKey::Name(name) = &key {
-                    analyze_maybe_global_index_expr(analyzer, index_expr, &name, value_expr_id);
+                    analyze_maybe_global_index_expr(analyzer, index_expr, name, value_expr_id);
                 }
             }
         }
@@ -160,7 +152,7 @@ fn analyze_maybe_global_index_expr(
             let position = index_expr.get_position();
             let name = name_token.get_name_text();
             let range = index_expr.get_range();
-            if let Some(decl) = analyzer.find_decl(&name, position) {
+            if let Some(decl) = analyzer.find_decl(name, position) {
                 let decl_id = decl.get_id();
                 analyzer
                     .db
@@ -195,7 +187,7 @@ pub fn analyze_for_stat(analyzer: &mut DeclAnalyzer, stat: LuaForStat) -> Option
         file_id,
         range,
         LuaDeclExtra::Local {
-            kind: it_var.syntax().kind().into(),
+            kind: it_var.syntax().kind(),
             attrib: Some(LocalAttribute::IterConst),
         },
         None,
@@ -223,7 +215,7 @@ pub fn analyze_for_range_stat(analyzer: &mut DeclAnalyzer, stat: LuaForRangeStat
             file_id,
             range,
             LuaDeclExtra::Local {
-                kind: var.syntax().kind().into(),
+                kind: var.syntax().kind(),
                 attrib: Some(LocalAttribute::IterConst),
             },
             None,
@@ -242,7 +234,7 @@ pub fn analyze_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaFuncStat) -> Opti
             let position = name_token.get_position();
             let name = name_token.get_name_text();
             let range = name_token.get_range();
-            if analyzer.find_decl(&name, position).is_none() {
+            if analyzer.find_decl(name, position).is_none() {
                 let decl = LuaDecl::new(
                     name,
                     file_id,
@@ -287,7 +279,7 @@ pub fn analyze_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaFuncStat) -> Opti
                 .add_member(owner_id, member);
 
             if let LuaMemberKey::Name(name) = &key {
-                analyze_maybe_global_index_expr(analyzer, &index_expr, &name, None);
+                analyze_maybe_global_index_expr(analyzer, &index_expr, name, None);
             }
             LuaSemanticDeclId::Member(member_id)
         }
@@ -317,7 +309,7 @@ pub fn analyze_local_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalFuncSt
         file_id,
         range,
         LuaDeclExtra::Local {
-            kind: local_name.syntax().kind().into(),
+            kind: local_name.syntax().kind(),
             attrib: None,
         },
         None,

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

@@ -34,17 +34,13 @@ fn analyze_diagnostic_disable(
     let comment = analyzer.comment.clone();
     let owner_block = comment.ancestors::<LuaBlock>().next()?;
     let owner_block_range = owner_block.get_range();
-    let is_file_disable = if let Some(_) = owner_block.get_parent::<LuaChunk>() {
-        true
-    } else {
-        false
-    };
+    let is_file_disable = owner_block.get_parent::<LuaChunk>().is_some();
 
     let diagnostic_index = analyzer.db.get_diagnostic_index_mut();
     if let Some(diagnostic_code_list) = diagnostic.get_code_list() {
         for code in diagnostic_code_list.get_codes() {
             let name = code.get_name_text();
-            let diagnostic_code = if let Some(code) = DiagnosticCode::from_str(name).ok() {
+            let diagnostic_code = if let Ok(code) = DiagnosticCode::from_str(name) {
                 code
             } else {
                 continue;
@@ -79,15 +75,15 @@ fn analyze_diagnostic_disable_next_line(
     let comment = analyzer.comment.clone();
     let comment_range = comment.get_range();
     let document = analyzer.db.get_vfs().get_document(&analyzer.file_id)?;
-    let comment_end_line = document.get_line(comment_range.end().into())?;
+    let comment_end_line = document.get_line(comment_range.end())?;
     let line_range = document.get_line_range(comment_end_line + 1)?;
     let valid_range = TextRange::new(comment_range.start(), line_range.end());
 
     let diagnostic_index = analyzer.db.get_diagnostic_index_mut();
     if let Some(diagnostic_code_list) = diagnostic.get_code_list() {
         for code in diagnostic_code_list.get_codes() {
             let name = code.get_name_text();
-            let diagnostic_code = if let Some(code) = DiagnosticCode::from_str(name).ok() {
+            let diagnostic_code = if let Ok(code) = DiagnosticCode::from_str(name) {
                 code
             } else {
                 continue;
@@ -115,14 +111,14 @@ fn analyze_diagnostic_disable_line(
     let comment = analyzer.comment.clone();
     let comment_range = comment.get_range();
     let document = analyzer.db.get_vfs().get_document(&analyzer.file_id)?;
-    let comment_end_line = document.get_line(comment_range.end().into())?;
+    let comment_end_line = document.get_line(comment_range.end())?;
     let valid_range = document.get_line_range(comment_end_line)?;
 
     let diagnostic_index = analyzer.db.get_diagnostic_index_mut();
     if let Some(diagnostic_code_list) = diagnostic.get_code_list() {
         for code in diagnostic_code_list.get_codes() {
             let name = code.get_name_text();
-            let diagnostic_code = if let Some(code) = DiagnosticCode::from_str(name).ok() {
+            let diagnostic_code = if let Ok(code) = DiagnosticCode::from_str(name) {
                 code
             } else {
                 continue;
@@ -151,7 +147,7 @@ fn analyze_diagnostic_enable(
     let diagnostic_code_list = diagnostic.get_code_list()?;
     for code in diagnostic_code_list.get_codes() {
         let name = code.get_name_text();
-        let diagnostic_code = if let Some(code) = DiagnosticCode::from_str(name).ok() {
+        let diagnostic_code = if let Ok(code) = DiagnosticCode::from_str(name) {
             code
         } else {
             continue;