internal: Work through temporarily allowed clippy lints, part 1

Cargo.toml

@@ -159,59 +159,25 @@ suspicious = { level = "warn", priority = -1 }
 result_unit_err = "allow"
 # We don't expose public APIs that matter like this
 len_without_is_empty = "allow"
-# We currently prefer explicit control flow return over `...?;` statements whose result is unused
-question_mark = "allow"
 # We have macros that rely on this currently
 enum_variant_names = "allow"
 # Builder pattern disagrees
 new_ret_no_self = "allow"
 
 ## Following lints should be tackled at some point
-bind_instead_of_map = "allow"
 borrowed_box = "allow"
 borrow_deref_ref = "allow"
-collapsible_if = "allow"
-collapsible_match = "allow"
-clone_on_copy = "allow"
 derivable_impls = "allow"
 derived_hash_with_manual_eq = "allow"
-double_parens = "allow"
-explicit_auto_deref = "allow"
 field_reassign_with_default = "allow"
 forget_non_drop = "allow"
 format_collect = "allow"
-for_kv_map = "allow"
-filter_map_bool_then = "allow"
-from_str_radix_10 = "allow"
-get_first = "allow"
-if_same_then_else = "allow"
 large_enum_variant = "allow"
-let_and_return = "allow"
-manual_find = "allow"
-manual_map = "allow"
-map_clone = "allow"
-match_like_matches_macro = "allow"
-match_single_binding = "allow"
-needless_borrow = "allow"
 needless_doctest_main = "allow"
-needless_lifetimes = "allow"
-needless_pass_by_value = "allow"
-needless_return = "allow"
 new_without_default = "allow"
-nonminimal_bool = "allow"
 non_canonical_clone_impl = "allow"
 non_canonical_partial_ord_impl = "allow"
-non_minimal_cfg = "allow"
-only_used_in_recursion = "allow"
-op_ref = "allow"
-option_map_unit_fn = "allow"
-partialeq_to_none = "allow"
-ptr_arg = "allow"
-redundant_closure = "allow"
-redundant_pattern_matching = "allow"
-search_is_some = "allow"
 self_named_constructors = "allow"
-single_match = "allow"
 skip_while_next = "allow"
 too_many_arguments = "allow"
 toplevel_ref_arg = "allow"

crates/base-db/src/input.rs

@@ -331,7 +331,7 @@ impl CrateData {
                 return false;
             }
 
-            if let Some(_) = opts.next() {
+            if opts.next().is_some() {
                 return false;
             }
         }

crates/hir-def/src/body.rs

@@ -258,12 +258,12 @@ impl Body {
                 }
             }
             Pat::Or(args) | Pat::Tuple { args, .. } | Pat::TupleStruct { args, .. } => {
-                args.iter().copied().for_each(|p| f(p));
+                args.iter().copied().for_each(f);
             }
             Pat::Ref { pat, .. } => f(*pat),
             Pat::Slice { prefix, slice, suffix } => {
                 let total_iter = prefix.iter().chain(slice.iter()).chain(suffix.iter());
-                total_iter.copied().for_each(|p| f(p));
+                total_iter.copied().for_each(f);
             }
             Pat::Record { args, .. } => {
                 args.iter().for_each(|RecordFieldPat { pat, .. }| f(*pat));
@@ -369,7 +369,7 @@ impl BodySourceMap {
     }
 
     pub fn label_syntax(&self, label: LabelId) -> LabelSource {
-        self.label_map_back[label].clone()
+        self.label_map_back[label]
     }
 
     pub fn node_label(&self, node: InFile<&ast::Label>) -> Option<LabelId> {
@@ -378,11 +378,11 @@ impl BodySourceMap {
     }
 
     pub fn field_syntax(&self, expr: ExprId) -> FieldSource {
-        self.field_map_back[&expr].clone()
+        self.field_map_back[&expr]
     }
 
     pub fn pat_field_syntax(&self, pat: PatId) -> PatFieldSource {
-        self.pat_field_map_back[&pat].clone()
+        self.pat_field_map_back[&pat]
     }
 
     pub fn macro_expansion_expr(&self, node: InFile<&ast::MacroExpr>) -> Option<ExprId> {

crates/hir-def/src/body/lower.rs

@@ -776,11 +776,10 @@ impl ExprCollector<'_> {
             None => self.collect_expr_opt(e.condition()),
         };
 
-        let break_expr =
-            self.alloc_expr(Expr::Break { expr: None, label: None }, syntax_ptr.clone());
+        let break_expr = self.alloc_expr(Expr::Break { expr: None, label: None }, syntax_ptr);
         let if_expr = self.alloc_expr(
             Expr::If { condition, then_branch: body, else_branch: Some(break_expr) },
-            syntax_ptr.clone(),
+            syntax_ptr,
         );
         self.alloc_expr(Expr::Loop { body: if_expr, label }, syntax_ptr)
     }
@@ -811,19 +810,19 @@ impl ExprCollector<'_> {
             return self.alloc_expr(Expr::Missing, syntax_ptr);
         };
         let head = self.collect_expr_opt(e.iterable());
-        let into_iter_fn_expr = self.alloc_expr(Expr::Path(into_iter_fn), syntax_ptr.clone());
+        let into_iter_fn_expr = self.alloc_expr(Expr::Path(into_iter_fn), syntax_ptr);
         let iterator = self.alloc_expr(
             Expr::Call {
                 callee: into_iter_fn_expr,
                 args: Box::new([head]),
                 is_assignee_expr: false,
             },
-            syntax_ptr.clone(),
+            syntax_ptr,
         );
         let none_arm = MatchArm {
             pat: self.alloc_pat_desugared(Pat::Path(Box::new(option_none))),
             guard: None,
-            expr: self.alloc_expr(Expr::Break { expr: None, label: None }, syntax_ptr.clone()),
+            expr: self.alloc_expr(Expr::Break { expr: None, label: None }, syntax_ptr),
         };
         let some_pat = Pat::TupleStruct {
             path: Some(Box::new(option_some)),
@@ -839,27 +838,25 @@ impl ExprCollector<'_> {
             }),
         };
         let iter_name = Name::generate_new_name();
-        let iter_expr =
-            self.alloc_expr(Expr::Path(Path::from(iter_name.clone())), syntax_ptr.clone());
+        let iter_expr = self.alloc_expr(Expr::Path(Path::from(iter_name.clone())), syntax_ptr);
         let iter_expr_mut = self.alloc_expr(
             Expr::Ref { expr: iter_expr, rawness: Rawness::Ref, mutability: Mutability::Mut },
-            syntax_ptr.clone(),
+            syntax_ptr,
         );
-        let iter_next_fn_expr = self.alloc_expr(Expr::Path(iter_next_fn), syntax_ptr.clone());
+        let iter_next_fn_expr = self.alloc_expr(Expr::Path(iter_next_fn), syntax_ptr);
         let iter_next_expr = self.alloc_expr(
             Expr::Call {
                 callee: iter_next_fn_expr,
                 args: Box::new([iter_expr_mut]),
                 is_assignee_expr: false,
             },
-            syntax_ptr.clone(),
+            syntax_ptr,
         );
         let loop_inner = self.alloc_expr(
             Expr::Match { expr: iter_next_expr, arms: Box::new([none_arm, some_arm]) },
-            syntax_ptr.clone(),
+            syntax_ptr,
         );
-        let loop_outer =
-            self.alloc_expr(Expr::Loop { body: loop_inner, label }, syntax_ptr.clone());
+        let loop_outer = self.alloc_expr(Expr::Loop { body: loop_inner, label }, syntax_ptr);
         let iter_binding = self.alloc_binding(iter_name, BindingAnnotation::Mutable);
         let iter_pat = self.alloc_pat_desugared(Pat::Bind { id: iter_binding, subpat: None });
         self.add_definition_to_binding(iter_binding, iter_pat);
@@ -868,7 +865,7 @@ impl ExprCollector<'_> {
                 expr: iterator,
                 arms: Box::new([MatchArm { pat: iter_pat, guard: None, expr: loop_outer }]),
             },
-            syntax_ptr.clone(),
+            syntax_ptr,
         )
     }
 
@@ -896,10 +893,10 @@ impl ExprCollector<'_> {
             return self.alloc_expr(Expr::Missing, syntax_ptr);
         };
         let operand = self.collect_expr_opt(e.expr());
-        let try_branch = self.alloc_expr(Expr::Path(try_branch), syntax_ptr.clone());
+        let try_branch = self.alloc_expr(Expr::Path(try_branch), syntax_ptr);
         let expr = self.alloc_expr(
             Expr::Call { callee: try_branch, args: Box::new([operand]), is_assignee_expr: false },
-            syntax_ptr.clone(),
+            syntax_ptr,
         );
         let continue_name = Name::generate_new_name();
         let continue_binding =
@@ -914,7 +911,7 @@ impl ExprCollector<'_> {
                 ellipsis: None,
             }),
             guard: None,
-            expr: self.alloc_expr(Expr::Path(Path::from(continue_name)), syntax_ptr.clone()),
+            expr: self.alloc_expr(Expr::Path(Path::from(continue_name)), syntax_ptr),
         };
         let break_name = Name::generate_new_name();
         let break_binding = self.alloc_binding(break_name.clone(), BindingAnnotation::Unannotated);
@@ -928,18 +925,18 @@ impl ExprCollector<'_> {
             }),
             guard: None,
             expr: {
-                let it = self.alloc_expr(Expr::Path(Path::from(break_name)), syntax_ptr.clone());
-                let callee = self.alloc_expr(Expr::Path(try_from_residual), syntax_ptr.clone());
+                let it = self.alloc_expr(Expr::Path(Path::from(break_name)), syntax_ptr);
+                let callee = self.alloc_expr(Expr::Path(try_from_residual), syntax_ptr);
                 let result = self.alloc_expr(
                     Expr::Call { callee, args: Box::new([it]), is_assignee_expr: false },
-                    syntax_ptr.clone(),
+                    syntax_ptr,
                 );
                 self.alloc_expr(
                     match self.current_try_block_label {
                         Some(label) => Expr::Break { expr: Some(result), label: Some(label) },
                         None => Expr::Return { expr: Some(result) },
                     },
-                    syntax_ptr.clone(),
+                    syntax_ptr,
                 )
             },
         };
@@ -1847,8 +1844,8 @@ impl ExprCollector<'_> {
             flags as u128,
             Some(BuiltinUint::U32),
         )));
-        let precision = self.make_count(&precision, argmap);
-        let width = self.make_count(&width, argmap);
+        let precision = self.make_count(precision, argmap);
+        let width = self.make_count(width, argmap);
 
         let format_placeholder_new = {
             let format_placeholder_new =
@@ -1994,7 +1991,7 @@ impl ExprCollector<'_> {
     fn alloc_expr(&mut self, expr: Expr, ptr: ExprPtr) -> ExprId {
         let src = self.expander.in_file(ptr);
         let id = self.body.exprs.alloc(expr);
-        self.source_map.expr_map_back.insert(id, src.clone());
+        self.source_map.expr_map_back.insert(id, src);
         self.source_map.expr_map.insert(src, id);
         id
     }
@@ -2022,7 +2019,7 @@ impl ExprCollector<'_> {
     fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
         let src = self.expander.in_file(ptr);
         let id = self.body.pats.alloc(pat);
-        self.source_map.pat_map_back.insert(id, src.clone());
+        self.source_map.pat_map_back.insert(id, src);
         self.source_map.pat_map.insert(src, id);
         id
     }
@@ -2037,7 +2034,7 @@ impl ExprCollector<'_> {
     fn alloc_label(&mut self, label: Label, ptr: LabelPtr) -> LabelId {
         let src = self.expander.in_file(ptr);
         let id = self.body.labels.alloc(label);
-        self.source_map.label_map_back.insert(id, src.clone());
+        self.source_map.label_map_back.insert(id, src);
         self.source_map.label_map.insert(src, id);
         id
     }

crates/hir-def/src/db.rs

@@ -259,10 +259,8 @@ fn crate_supports_no_std(db: &dyn DefDatabase, crate_id: CrateId) -> bool {
             None => continue,
         };
 
-        let segments = tt.split(|tt| match tt {
-            tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ',' => true,
-            _ => false,
-        });
+        let segments =
+            tt.split(|tt| matches!(tt, tt::TokenTree::Leaf(tt::Leaf::Punct(p)) if p.char == ','));
         for output in segments.skip(1) {
             match output {
                 [tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.text == "no_std" => {

crates/hir-def/src/find_path.rs

@@ -230,7 +230,7 @@ fn find_path_for_module(
     }
 
     if let value @ Some(_) =
-        find_in_prelude(ctx.db, &root_def_map, &def_map, ItemInNs::Types(module_id.into()), from)
+        find_in_prelude(ctx.db, &root_def_map, def_map, ItemInNs::Types(module_id.into()), from)
     {
         return value.zip(Some(Stable));
     }

crates/hir-def/src/generics.rs

@@ -400,9 +400,8 @@ impl GenericParams {
                             params
                                 .type_or_consts
                                 .iter()
-                                .filter_map(|(idx, param)| {
-                                    enabled(idx.into()).then(|| param.clone())
-                                })
+                                .filter(|(idx, _)| enabled((*idx).into()))
+                                .map(|(_, param)| param.clone())
                                 .collect()
                         }),
                     lifetimes: all_lifetimes_enabled
@@ -411,9 +410,8 @@ impl GenericParams {
                             params
                                 .lifetimes
                                 .iter()
-                                .filter_map(|(idx, param)| {
-                                    enabled(idx.into()).then(|| param.clone())
-                                })
+                                .filter(|(idx, _)| enabled((*idx).into()))
+                                .map(|(_, param)| param.clone())
                                 .collect()
                         }),
                     where_predicates: params.where_predicates.clone(),

crates/hir-def/src/hir/type_ref.rs

@@ -410,11 +410,7 @@ impl ConstRef {
         lower_ctx: &LowerCtx<'_>,
         param: &ast::ConstParam,
     ) -> Option<Self> {
-        let default = param.default_val();
-        match default {
-            Some(_) => Some(Self::from_const_arg(lower_ctx, default)),
-            None => None,
-        }
+        param.default_val().map(|default| Self::from_const_arg(lower_ctx, Some(default)))
     }
 
     pub fn display<'a>(&'a self, db: &'a dyn ExpandDatabase) -> impl fmt::Display + 'a {

crates/hir-def/src/import_map.rs

@@ -294,14 +294,14 @@ impl SearchMode {
     pub fn check(self, query: &str, case_sensitive: bool, candidate: &str) -> bool {
         match self {
             SearchMode::Exact if case_sensitive => candidate == query,
-            SearchMode::Exact => candidate.eq_ignore_ascii_case(&query),
+            SearchMode::Exact => candidate.eq_ignore_ascii_case(query),
             SearchMode::Prefix => {
                 query.len() <= candidate.len() && {
                     let prefix = &candidate[..query.len() as usize];
                     if case_sensitive {
                         prefix == query
                     } else {
-                        prefix.eq_ignore_ascii_case(&query)
+                        prefix.eq_ignore_ascii_case(query)
                     }
                 }
             }
@@ -382,11 +382,11 @@ impl Query {
     }
 
     fn matches_assoc_mode(&self, is_trait_assoc_item: IsTraitAssocItem) -> bool {
-        match (is_trait_assoc_item, self.assoc_mode) {
+        !matches!(
+            (is_trait_assoc_item, self.assoc_mode),
             (IsTraitAssocItem::Yes, AssocSearchMode::Exclude)
-            | (IsTraitAssocItem::No, AssocSearchMode::AssocItemsOnly) => false,
-            _ => true,
-        }
+                | (IsTraitAssocItem::No, AssocSearchMode::AssocItemsOnly)
+        )
     }
 }
 

crates/hir-def/src/lang_item.rs

@@ -192,7 +192,7 @@ impl LangItems {
 
 pub(crate) fn lang_attr(db: &dyn DefDatabase, item: AttrDefId) -> Option<LangItem> {
     let attrs = db.attrs(item);
-    attrs.by_key("lang").string_value().and_then(|it| LangItem::from_str(&it))
+    attrs.by_key("lang").string_value().and_then(|it| LangItem::from_str(it))
 }
 
 pub(crate) fn notable_traits_in_deps(

crates/hir-def/src/lib.rs

@@ -733,9 +733,7 @@ pub struct InTypeConstLoc {
 
 impl PartialEq for InTypeConstLoc {
     fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-            && self.owner == other.owner
-            && &*self.expected_ty == &*other.expected_ty
+        self.id == other.id && self.owner == other.owner && *self.expected_ty == *other.expected_ty
     }
 }