minor: fix some clippy lints

Author: Veykril

crates/base_db/src/input.rs

@@ -521,8 +521,8 @@ impl fmt::Display for CyclicDependenciesError {
         write!(
             f,
             "cyclic deps: {} -> {}, alternative path: {}",
-            render(&self.from()),
-            render(&self.to()),
+            render(self.from()),
+            render(self.to()),
             path
         )
     }

crates/flycheck/src/lib.rs

@@ -339,12 +339,7 @@ impl CargoActor {
                         cargo_metadata::Message::CompilerMessage(msg) => {
                             self.sender.send(CargoMessage::Diagnostic(msg.message)).unwrap()
                         }
-
-                        cargo_metadata::Message::CompilerArtifact(_)
-                        | cargo_metadata::Message::BuildScriptExecuted(_)
-                        | cargo_metadata::Message::BuildFinished(_)
-                        | cargo_metadata::Message::TextLine(_)
-                        | _ => (),
+                        _ => (),
                     },
                     JsonMessage::Rustc(message) => {
                         self.sender.send(CargoMessage::Diagnostic(message)).unwrap()

crates/hir/src/has_source.rs

@@ -60,9 +60,9 @@ impl HasSource for Adt {
     type Ast = ast::Adt;
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
         match self {
-            Adt::Struct(s) => Some(s.source(db)?.map(|s| ast::Adt::Struct(s))),
-            Adt::Union(u) => Some(u.source(db)?.map(|u| ast::Adt::Union(u))),
-            Adt::Enum(e) => Some(e.source(db)?.map(|e| ast::Adt::Enum(e))),
+            Adt::Struct(s) => Some(s.source(db)?.map(ast::Adt::Struct)),
+            Adt::Union(u) => Some(u.source(db)?.map(ast::Adt::Union)),
+            Adt::Enum(e) => Some(e.source(db)?.map(ast::Adt::Enum)),
         }
     }
 }

crates/hir/src/lib.rs

@@ -2960,9 +2960,9 @@ impl ScopeDef {
 impl From<ItemInNs> for ScopeDef {
     fn from(item: ItemInNs) -> Self {
         match item {
-            ItemInNs::Types(id) => ScopeDef::ModuleDef(id.into()),
-            ItemInNs::Values(id) => ScopeDef::ModuleDef(id.into()),
-            ItemInNs::Macros(id) => ScopeDef::MacroDef(id.into()),
+            ItemInNs::Types(id) => ScopeDef::ModuleDef(id),
+            ItemInNs::Values(id) => ScopeDef::ModuleDef(id),
+            ItemInNs::Macros(id) => ScopeDef::MacroDef(id),
         }
     }
 }

crates/hir/src/semantics.rs

@@ -864,7 +864,7 @@ impl<'db> SemanticsImpl<'db> {
     }
 
     fn is_unsafe_ident_pat(&self, ident_pat: &ast::IdentPat) -> bool {
-        if !ident_pat.ref_token().is_some() {
+        if ident_pat.ref_token().is_none() {
             return false;
         }
 

crates/hir_def/src/item_tree/lower.rs

@@ -264,8 +264,7 @@ impl<'a> Ctx<'a> {
         let name = Name::new_tuple_field(idx);
         let visibility = self.lower_visibility(field);
         let type_ref = self.lower_type_ref_opt(field.ty());
-        let res = Field { name, type_ref, visibility };
-        res
+        Field { name, type_ref, visibility }
     }
 
     fn lower_union(&mut self, union: &ast::Union) -> Option<FileItemTreeId<Union>> {

crates/hir_def/src/nameres/collector.rs

@@ -384,7 +384,7 @@ impl DefCollector<'_> {
         self.unresolved_imports.extend(partial_resolved);
         self.resolve_imports();
 
-        let unresolved_imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
+        let unresolved_imports = std::mem::take(&mut self.unresolved_imports);
         // show unresolved imports in completion, etc
         for directive in &unresolved_imports {
             self.record_resolved_import(directive)
@@ -417,7 +417,7 @@ impl DefCollector<'_> {
     fn reseed_with_unresolved_attribute(&mut self) -> ReachedFixedPoint {
         cov_mark::hit!(unresolved_attribute_fallback);
 
-        let mut unresolved_macros = std::mem::replace(&mut self.unresolved_macros, Vec::new());
+        let mut unresolved_macros = std::mem::take(&mut self.unresolved_macros);
         let pos = unresolved_macros.iter().position(|directive| {
             if let MacroDirectiveKind::Attr { ast_id, mod_item, attr } = &directive.kind {
                 self.skip_attrs.insert(ast_id.ast_id.with_value(*mod_item), attr.id);
@@ -689,7 +689,7 @@ impl DefCollector<'_> {
     /// Tries to resolve every currently unresolved import.
     fn resolve_imports(&mut self) -> ReachedFixedPoint {
         let mut res = ReachedFixedPoint::Yes;
-        let imports = std::mem::replace(&mut self.unresolved_imports, Vec::new());
+        let imports = std::mem::take(&mut self.unresolved_imports);
         let imports = imports
             .into_iter()
             .filter_map(|mut directive| {
@@ -1005,7 +1005,7 @@ impl DefCollector<'_> {
     }
 
     fn resolve_macros(&mut self) -> ReachedFixedPoint {
-        let mut macros = std::mem::replace(&mut self.unresolved_macros, Vec::new());
+        let mut macros = std::mem::take(&mut self.unresolved_macros);
         let mut resolved = Vec::new();
         let mut res = ReachedFixedPoint::Yes;
         macros.retain(|directive| {
@@ -1279,13 +1279,12 @@ impl DefCollector<'_> {
 
         for directive in &self.unresolved_imports {
             if let ImportSource::Import { id: import, use_tree } = &directive.import.source {
-                match (directive.import.path.segments().first(), &directive.import.path.kind) {
-                    (Some(krate), PathKind::Plain | PathKind::Abs) => {
-                        if diagnosed_extern_crates.contains(krate) {
-                            continue;
-                        }
+                if let (Some(krate), PathKind::Plain | PathKind::Abs) =
+                    (directive.import.path.segments().first(), &directive.import.path.kind)
+                {
+                    if diagnosed_extern_crates.contains(krate) {
+                        continue;
                     }
-                    _ => {}
                 }
 
                 self.def_map.diagnostics.push(DefDiagnostic::unresolved_import(
@@ -1579,13 +1578,13 @@ impl ModCollector<'_, '_> {
                 {
                     Ok((file_id, is_mod_rs, mod_dir)) => {
                         let item_tree = db.file_item_tree(file_id.into());
-                        if item_tree
+                        let is_enabled = item_tree
                             .top_level_attrs(db, self.def_collector.def_map.krate)
                             .cfg()
                             .map_or(true, |cfg| {
                                 self.def_collector.cfg_options.check(&cfg) != Some(false)
-                            })
-                        {
+                            });
+                        if is_enabled {
                             let module_id = self.push_child_module(
                                 module.name.clone(),
                                 ast_id,

crates/hir_expand/src/eager.rs

@@ -107,7 +107,7 @@ pub fn expand_eager_macro(
     mut diagnostic_sink: &mut dyn FnMut(mbe::ExpandError),
 ) -> Result<MacroCallId, ErrorEmitted> {
     let parsed_args = diagnostic_sink.option_with(
-        || Some(mbe::syntax_node_to_token_tree(&macro_call.value.token_tree()?.syntax()).0),
+        || Some(mbe::syntax_node_to_token_tree(macro_call.value.token_tree()?.syntax()).0),
         || err("malformed macro invocation"),
     )?;
 

crates/hir_ty/src/chalk_db.rs

@@ -205,10 +205,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                 let (datas, binders) = (*datas).as_ref().into_value_and_skipped_binders();
                 let data = &datas.impl_traits[idx as usize];
                 let bound = OpaqueTyDatumBound {
-                    bounds: make_only_type_binders(
-                        1,
-                        data.bounds.skip_binders().iter().cloned().collect(),
-                    ),
+                    bounds: make_only_type_binders(1, data.bounds.skip_binders().to_vec()),
                     where_clauses: make_only_type_binders(0, vec![]),
                 };
                 chalk_ir::Binders::new(binders, bound)
@@ -309,7 +306,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
         let sig_ty = substs.at(&Interner, 0).assert_ty_ref(&Interner).clone();
         let sig = &sig_ty.callable_sig(self.db).expect("first closure param should be fn ptr");
         let io = rust_ir::FnDefInputsAndOutputDatum {
-            argument_types: sig.params().iter().cloned().collect(),
+            argument_types: sig.params().to_vec(),
             return_type: sig.ret().clone(),
         };
         make_only_type_binders(0, io.shifted_in(&Interner))
@@ -675,7 +672,7 @@ pub(crate) fn fn_def_datum_query(
         inputs_and_output: make_only_type_binders(
             0,
             rust_ir::FnDefInputsAndOutputDatum {
-                argument_types: sig.params().iter().cloned().collect(),
+                argument_types: sig.params().to_vec(),
                 return_type: sig.ret().clone(),
             }
             .shifted_in(&Interner),

crates/hir_ty/src/chalk_ext.rs

@@ -242,7 +242,7 @@ impl TyExt for Ty {
                         let substs = TyBuilder::type_params_subst(db, id.parent);
                         let predicates = db
                             .generic_predicates(id.parent)
-                            .into_iter()
+                            .iter()
                             .map(|pred| pred.clone().substitute(&Interner, &substs))
                             .filter(|wc| match &wc.skip_binders() {
                                 WhereClause::Implemented(tr) => {