internal: fix most Clippy lints

crates/base-db/src/input.rs

@@ -639,7 +639,7 @@ impl CrateGraph {
             let res = self.arena.iter().find_map(|(id, data)| {
                 match (&data.origin, &crate_data.origin) {
                     (a, b) if a == b => {
-                        if data.eq_ignoring_origin_and_deps(&crate_data, false) {
+                        if data.eq_ignoring_origin_and_deps(crate_data, false) {
                             return Some((id, false));
                         }
                     }
@@ -651,8 +651,8 @@ impl CrateGraph {
                         // version and discard the library one as the local version may have
                         // dev-dependencies that we want to keep resolving. See #15656 for more
                         // information.
-                        if data.eq_ignoring_origin_and_deps(&crate_data, true) {
-                            return Some((id, if a.is_local() { false } else { true }));
+                        if data.eq_ignoring_origin_and_deps(crate_data, true) {
+                            return Some((id, !a.is_local()));
                         }
                     }
                     (_, _) => return None,

crates/hir-expand/src/ast_id_map.rs

@@ -191,7 +191,7 @@ impl AstIdMap {
 
     /// The [`AstId`] of the root node
     pub fn root(&self) -> SyntaxNodePtr {
-        self.arena[Idx::from_raw(RawIdx::from_u32(0))].clone()
+        self.arena[Idx::from_raw(RawIdx::from_u32(0))]
     }
 
     pub fn ast_id<N: AstIdNode>(&self, item: &N) -> FileAstId<N> {
@@ -213,11 +213,11 @@ impl AstIdMap {
     }
 
     pub fn get<N: AstIdNode>(&self, id: FileAstId<N>) -> AstPtr<N> {
-        AstPtr::try_from_raw(self.arena[id.raw].clone()).unwrap()
+        AstPtr::try_from_raw(self.arena[id.raw]).unwrap()
     }
 
     pub fn get_erased(&self, id: ErasedFileAstId) -> SyntaxNodePtr {
-        self.arena[id].clone()
+        self.arena[id]
     }
 
     fn erased_ast_id(&self, item: &SyntaxNode) -> ErasedFileAstId {
@@ -239,9 +239,7 @@ impl AstIdMap {
 }
 
 fn hash_ptr(ptr: &SyntaxNodePtr) -> u64 {
-    let mut hasher = BuildHasherDefault::<FxHasher>::default().build_hasher();
-    ptr.hash(&mut hasher);
-    hasher.finish()
+    BuildHasherDefault::<FxHasher>::default().hash_one(ptr)
 }
 
 #[derive(Copy, Clone, PartialEq, Eq)]

crates/hir-expand/src/attrs.rs

@@ -31,7 +31,7 @@ impl ops::Deref for RawAttrs {
 
     fn deref(&self) -> &[Attr] {
         match &self.entries {
-            Some(it) => &*it,
+            Some(it) => it,
             None => &[],
         }
     }
@@ -79,7 +79,7 @@ impl RawAttrs {
                 Self {
                     entries: Some(Arc::from_iter(a.iter().cloned().chain(b.iter().map(|it| {
                         let mut it = it.clone();
-                        it.id.id = it.id.ast_index() as u32 + last_ast_index
+                        it.id.id = (it.id.ast_index() as u32 + last_ast_index)
                             | (it.id.cfg_attr_index().unwrap_or(0) as u32)
                                 << AttrId::AST_INDEX_BITS;
                         it

crates/hir-expand/src/builtin_derive_macro.rs

@@ -425,7 +425,7 @@ fn clone_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<t
         let name = &adt.name;
         let patterns = adt.shape.as_pattern(span, name);
         let exprs = adt.shape.as_pattern_map(name, |it| quote! {span => #it .clone() }, span);
-        let arms = patterns.into_iter().zip(exprs.into_iter()).map(|(pat, expr)| {
+        let arms = patterns.into_iter().zip(exprs).map(|(pat, expr)| {
             let fat_arrow = fat_arrow(span);
             quote! {span =>
                 #pat #fat_arrow #expr,

crates/hir-expand/src/builtin_fn_macro.rs

@@ -125,7 +125,7 @@ fn mk_pound(span: Span) -> tt::Subtree {
         vec![crate::tt::Leaf::Punct(crate::tt::Punct {
             char: '#',
             spacing: crate::tt::Spacing::Alone,
-            span: span,
+            span,
         })
         .into()],
         span,
@@ -279,9 +279,9 @@ fn format_args_expand_general(
     let pound = mk_pound(span);
     let mut tt = tt.clone();
     tt.delimiter.kind = tt::DelimiterKind::Parenthesis;
-    return ExpandResult::ok(quote! {span =>
+    ExpandResult::ok(quote! {span =>
         builtin #pound format_args #tt
-    });
+    })
 }
 
 fn asm_expand(
@@ -624,7 +624,7 @@ fn relative_file(
 
 fn parse_string(tt: &tt::Subtree) -> Result<String, ExpandError> {
     tt.token_trees
-        .get(0)
+        .first()
         .and_then(|tt| match tt {
             tt::TokenTree::Leaf(tt::Leaf::Literal(it)) => unquote_str(it),
             _ => None,

crates/hir-expand/src/db.rs

@@ -633,8 +633,8 @@ fn decl_macro_expander(
                         map.as_ref(),
                         map.span_for_range(macro_rules.macro_rules_token().unwrap().text_range()),
                     );
-                    let mac = mbe::DeclarativeMacro::parse_macro_rules(&tt, is_2021, new_meta_vars);
-                    mac
+
+                    mbe::DeclarativeMacro::parse_macro_rules(&tt, is_2021, new_meta_vars)
                 }
                 None => mbe::DeclarativeMacro::from_err(
                     mbe::ParseError::Expected("expected a token tree".into()),
@@ -651,8 +651,8 @@ fn decl_macro_expander(
                         map.as_ref(),
                         map.span_for_range(macro_def.macro_token().unwrap().text_range()),
                     );
-                    let mac = mbe::DeclarativeMacro::parse_macro2(&tt, is_2021, new_meta_vars);
-                    mac
+
+                    mbe::DeclarativeMacro::parse_macro2(&tt, is_2021, new_meta_vars)
                 }
                 None => mbe::DeclarativeMacro::from_err(
                     mbe::ParseError::Expected("expected a token tree".into()),
@@ -722,7 +722,7 @@ fn macro_expand(
                     db.decl_macro_expander(loc.def.krate, id).expand(db, arg.clone(), macro_call_id)
                 }
                 MacroDefKind::BuiltIn(it, _) => {
-                    it.expand(db, macro_call_id, &arg).map_err(Into::into)
+                    it.expand(db, macro_call_id, arg).map_err(Into::into)
                 }
                 // This might look a bit odd, but we do not expand the inputs to eager macros here.
                 // Eager macros inputs are expanded, well, eagerly when we collect the macro calls.
@@ -746,10 +746,10 @@ fn macro_expand(
                     };
                 }
                 MacroDefKind::BuiltInEager(it, _) => {
-                    it.expand(db, macro_call_id, &arg).map_err(Into::into)
+                    it.expand(db, macro_call_id, arg).map_err(Into::into)
                 }
                 MacroDefKind::BuiltInAttr(it, _) => {
-                    let mut res = it.expand(db, macro_call_id, &arg);
+                    let mut res = it.expand(db, macro_call_id, arg);
                     fixup::reverse_fixups(&mut res.value, &undo_info);
                     res
                 }

crates/hir-expand/src/fixup.rs

@@ -68,7 +68,7 @@ pub(crate) fn fixup_syntax(
 
         let node_range = node.text_range();
         if can_handle_error(&node) && has_error_to_handle(&node) {
-            remove.insert(node.clone().into());
+            remove.insert(node.clone());
             // the node contains an error node, we have to completely replace it by something valid
             let original_tree = mbe::syntax_node_to_token_tree(&node, span_map, call_site);
             let idx = original.len() as u32;

crates/hir-expand/src/lib.rs

@@ -77,15 +77,15 @@ macro_rules! impl_intern_lookup {
         impl $crate::Intern for $loc {
             type Database<'db> = dyn $db + 'db;
             type ID = $id;
-            fn intern<'db>(self, db: &Self::Database<'db>) -> $id {
+            fn intern(self, db: &Self::Database<'_>) -> $id {
                 db.$intern(self)
             }
         }
 
         impl $crate::Lookup for $id {
             type Database<'db> = dyn $db + 'db;
             type Data = $loc;
-            fn lookup<'db>(&self, db: &Self::Database<'db>) -> $loc {
+            fn lookup(&self, db: &Self::Database<'_>) -> $loc {
                 db.$lookup(*self)
             }
         }
@@ -96,13 +96,13 @@ macro_rules! impl_intern_lookup {
 pub trait Intern {
     type Database<'db>: ?Sized;
     type ID;
-    fn intern<'db>(self, db: &Self::Database<'db>) -> Self::ID;
+    fn intern(self, db: &Self::Database<'_>) -> Self::ID;
 }
 
 pub trait Lookup {
     type Database<'db>: ?Sized;
     type Data;
-    fn lookup<'db>(&self, db: &Self::Database<'db>) -> Self::Data;
+    fn lookup(&self, db: &Self::Database<'_>) -> Self::Data;
 }
 
 impl_intern_lookup!(
@@ -425,7 +425,7 @@ impl MacroDefId {
 
     pub fn ast_id(&self) -> Either<AstId<ast::Macro>, AstId<ast::Fn>> {
         match self.kind {
-            MacroDefKind::ProcMacro(.., id) => return Either::Right(id),
+            MacroDefKind::ProcMacro(.., id) => Either::Right(id),
             MacroDefKind::Declarative(id)
             | MacroDefKind::BuiltIn(_, id)
             | MacroDefKind::BuiltInAttr(_, id)
@@ -657,10 +657,10 @@ impl ExpansionInfo {
     }
 
     /// Maps the passed in file range down into a macro expansion if it is the input to a macro call.
-    pub fn map_range_down<'a>(
-        &'a self,
+    pub fn map_range_down(
+        &self,
         span: Span,
-    ) -> Option<InMacroFile<impl Iterator<Item = SyntaxToken> + 'a>> {
+    ) -> Option<InMacroFile<impl Iterator<Item = SyntaxToken> + '_>> {
         let tokens = self
             .exp_map
             .ranges_with_span(span)

crates/hir-expand/src/mod_path.rs

@@ -301,7 +301,7 @@ pub fn resolve_crate_root(db: &dyn ExpandDatabase, mut ctxt: SyntaxContextId) ->
         result_mark = Some(mark);
     }
 
-    result_mark.flatten().map(|call| db.lookup_intern_macro_call(call.into()).def.krate)
+    result_mark.flatten().map(|call| db.lookup_intern_macro_call(call).def.krate)
 }
 
 pub use crate::name as __name;

crates/hir-expand/src/quote.rs

@@ -18,13 +18,13 @@ pub(crate) const fn dollar_crate(span: Span) -> tt::Ident<Span> {
 #[macro_export]
 macro_rules! __quote {
     ($span:ident) => {
-        Vec::<crate::tt::TokenTree>::new()
+        Vec::<$crate::tt::TokenTree>::new()
     };
 
     ( @SUBTREE($span:ident) $delim:ident $($tt:tt)* ) => {
         {
             let children = $crate::__quote!($span $($tt)*);
-            crate::tt::Subtree {
+            $crate::tt::Subtree {
                 delimiter: crate::tt::Delimiter {
                     kind: crate::tt::DelimiterKind::$delim,
                     open: $span,

crates/hir-ty/src/chalk_db.rs

@@ -230,7 +230,7 @@ impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
         well_known_trait: rust_ir::WellKnownTrait,
     ) -> Option<chalk_ir::TraitId<Interner>> {
         let lang_attr = lang_item_from_well_known_trait(well_known_trait);
-        let trait_ = match self.db.lang_item(self.krate, lang_attr.into()) {
+        let trait_ = match self.db.lang_item(self.krate, lang_attr) {
             Some(LangItemTarget::Trait(trait_)) => trait_,
             _ => return None,
         };

crates/hir-ty/src/chalk_ext.rs

@@ -218,7 +218,7 @@ impl TyExt for Ty {
             // invariant ensured by `TyLoweringContext::lower_dyn_trait()`.
             // FIXME: dyn types may not have principal trait and we don't want to return auto trait
             // here.
-            TyKind::Dyn(dyn_ty) => dyn_ty.bounds.skip_binders().interned().get(0).and_then(|b| {
+            TyKind::Dyn(dyn_ty) => dyn_ty.bounds.skip_binders().interned().first().and_then(|b| {
                 match b.skip_binders() {
                     WhereClause::Implemented(trait_ref) => Some(trait_ref),
                     _ => None,
@@ -427,7 +427,7 @@ pub trait DynTyExt {
 
 impl DynTyExt for DynTy {
     fn principal(&self) -> Option<&TraitRef> {
-        self.bounds.skip_binders().interned().get(0).and_then(|b| match b.skip_binders() {
+        self.bounds.skip_binders().interned().first().and_then(|b| match b.skip_binders() {
             crate::WhereClause::Implemented(trait_ref) => Some(trait_ref),
             _ => None,
         })

crates/hir-ty/src/consteval.rs

@@ -173,7 +173,7 @@ pub fn try_const_usize(db: &dyn HirDatabase, c: &Const) -> Option<u128> {
         chalk_ir::ConstValue::InferenceVar(_) => None,
         chalk_ir::ConstValue::Placeholder(_) => None,
         chalk_ir::ConstValue::Concrete(c) => match &c.interned {
-            ConstScalar::Bytes(it, _) => Some(u128::from_le_bytes(pad16(&it, false))),
+            ConstScalar::Bytes(it, _) => Some(u128::from_le_bytes(pad16(it, false))),
             ConstScalar::UnevaluatedConst(c, subst) => {
                 let ec = db.const_eval(*c, subst.clone(), None).ok()?;
                 try_const_usize(db, &ec)
@@ -298,7 +298,7 @@ pub(crate) fn eval_to_const(
         body[expr].walk_child_exprs(|idx| r |= has_closure(body, idx));
         r
     }
-    if has_closure(&ctx.body, expr) {
+    if has_closure(ctx.body, expr) {
         // Type checking clousres need an isolated body (See the above FIXME). Bail out early to prevent panic.
         return unknown_const(infer[expr].clone());
     }
@@ -308,7 +308,7 @@ pub(crate) fn eval_to_const(
             return c;
         }
     }
-    if let Ok(mir_body) = lower_to_mir(ctx.db, ctx.owner, &ctx.body, &infer, expr) {
+    if let Ok(mir_body) = lower_to_mir(ctx.db, ctx.owner, ctx.body, &infer, expr) {
         if let Ok(result) = interpret_mir(db, Arc::new(mir_body), true, None).0 {
             return result;
         }

crates/hir-ty/src/diagnostics/decl_check.rs

@@ -387,7 +387,7 @@ impl<'a> DeclValidator<'a> {
 
         for (id, replacement) in pats_replacements {
             if let Ok(source_ptr) = source_map.pat_syntax(id) {
-                if let Some(ptr) = source_ptr.value.clone().cast::<ast::IdentPat>() {
+                if let Some(ptr) = source_ptr.value.cast::<ast::IdentPat>() {
                     let root = source_ptr.file_syntax(self.db.upcast());
                     let ident_pat = ptr.to_node(&root);
                     let parent = match ident_pat.syntax().parent() {

crates/hir-ty/src/diagnostics/expr.rs

@@ -141,8 +141,8 @@ impl ExprValidator {
                     );
                 }
             }
-            _ => return,
-        };
+            _ => (),
+        }
     }
 
     fn validate_match(

crates/hir-ty/src/diagnostics/match_check/usefulness.rs

@@ -409,7 +409,7 @@ impl<'p> Matrix<'p> {
 
     /// Number of columns of this matrix. `None` is the matrix is empty.
     pub(super) fn _column_count(&self) -> Option<usize> {
-        self.patterns.get(0).map(|r| r.len())
+        self.patterns.first().map(|r| r.len())
     }
 
     /// Pushes a new row to the matrix. If the row starts with an or-pattern, this recursively