single_match

Urhengulas · Urhengulas · commit b1a0c9ac403d · 2024-01-19T18:31:15.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -178,7 +178,6 @@ new_without_default = "allow"
 non_canonical_clone_impl = "allow"
 non_canonical_partial_ord_impl = "allow"
 self_named_constructors = "allow"
-single_match = "allow"
 skip_while_next = "allow"
 too_many_arguments = "allow"
 toplevel_ref_arg = "allow"
diff --git a/crates/hir-ty/src/diagnostics/expr.rs b/crates/hir-ty/src/diagnostics/expr.rs
@@ -114,34 +114,26 @@ impl ExprValidator {
     ) {
         // Check that the number of arguments matches the number of parameters.
 
-        // FIXME: Due to shortcomings in the current type system implementation, only emit this
-        // diagnostic if there are no type mismatches in the containing function.
         if self.infer.expr_type_mismatches().next().is_some() {
-            return;
-        }
-
-        match expr {
-            Expr::MethodCall { receiver, .. } => {
-                let (callee, _) = match self.infer.method_resolution(call_id) {
-                    Some(it) => it,
-                    None => return,
-                };
-
-                if filter_map_next_checker
-                    .get_or_insert_with(|| {
-                        FilterMapNextChecker::new(&self.owner.resolver(db.upcast()), db)
-                    })
-                    .check(call_id, receiver, &callee)
-                    .is_some()
-                {
-                    self.diagnostics.push(
-                        BodyValidationDiagnostic::ReplaceFilterMapNextWithFindMap {
-                            method_call_expr: call_id,
-                        },
-                    );
-                }
+            // FIXME: Due to shortcomings in the current type system implementation, only emit
+            // this diagnostic if there are no type mismatches in the containing function.
+        } else if let Expr::MethodCall { receiver, .. } = expr {
+            let (callee, _) = match self.infer.method_resolution(call_id) {
+                Some(it) => it,
+                None => return,
+            };
+
+            if filter_map_next_checker
+                .get_or_insert_with(|| {
+                    FilterMapNextChecker::new(&self.owner.resolver(db.upcast()), db)
+                })
+                .check(call_id, receiver, &callee)
+                .is_some()
+            {
+                self.diagnostics.push(BodyValidationDiagnostic::ReplaceFilterMapNextWithFindMap {
+                    method_call_expr: call_id,
+                });
             }
-            _ => (),
         }
     }
 
diff --git a/crates/hir-ty/src/infer/closure.rs b/crates/hir-ty/src/infer/closure.rs
@@ -142,13 +142,10 @@ impl HirPlace {
         mut current_capture: CaptureKind,
         len: usize,
     ) -> CaptureKind {
-        match current_capture {
-            CaptureKind::ByRef(BorrowKind::Mut { .. }) => {
-                if self.projections[len..].iter().any(|it| *it == ProjectionElem::Deref) {
-                    current_capture = CaptureKind::ByRef(BorrowKind::Unique);
-                }
+        if let CaptureKind::ByRef(BorrowKind::Mut { .. }) = current_capture {
+            if self.projections[len..].iter().any(|it| *it == ProjectionElem::Deref) {
+                current_capture = CaptureKind::ByRef(BorrowKind::Unique);
             }
-            _ => (),
         }
         current_capture
     }
diff --git a/crates/hir-ty/src/mir/borrowck.rs b/crates/hir-ty/src/mir/borrowck.rs
@@ -339,11 +339,8 @@ fn push_mut_span(local: LocalId, span: MirSpan, result: &mut ArenaMap<LocalId, M
 }
 
 fn record_usage(local: LocalId, result: &mut ArenaMap<LocalId, MutabilityReason>) {
-    match &mut result[local] {
-        it @ MutabilityReason::Unused => {
-            *it = MutabilityReason::Not;
-        }
-        _ => (),
+    if let it @ MutabilityReason::Unused = &mut result[local] {
+        *it = MutabilityReason::Not;
     };
 }
 
diff --git a/crates/hir-ty/src/mir/lower.rs b/crates/hir-ty/src/mir/lower.rs
@@ -288,12 +288,9 @@ impl<'ctx> MirLowerCtx<'ctx> {
         current: BasicBlockId,
     ) -> Result<Option<(Operand, BasicBlockId)>> {
         if !self.has_adjustments(expr_id) {
-            match &self.body.exprs[expr_id] {
-                Expr::Literal(l) => {
-                    let ty = self.expr_ty_without_adjust(expr_id);
-                    return Ok(Some((self.lower_literal_to_operand(ty, l)?, current)));
-                }
-                _ => (),
+            if let Expr::Literal(l) = &self.body.exprs[expr_id] {
+                let ty = self.expr_ty_without_adjust(expr_id);
+                return Ok(Some((self.lower_literal_to_operand(ty, l)?, current)));
             }
         }
         let Some((p, current)) = self.lower_expr_as_place(current, expr_id, true)? else {
diff --git a/crates/ide-assists/src/handlers/extract_module.rs b/crates/ide-assists/src/handlers/extract_module.rs
@@ -689,27 +689,22 @@ fn does_source_exists_outside_sel_in_same_mod(
     match def {
         Definition::Module(x) => {
             let source = x.definition_source(ctx.db());
-            let have_same_parent;
-            if let Some(ast_module) = &curr_parent_module {
+            let have_same_parent = if let Some(ast_module) = &curr_parent_module {
                 if let Some(hir_module) = x.parent(ctx.db()) {
-                    have_same_parent =
-                        compare_hir_and_ast_module(ast_module, hir_module, ctx).is_some();
+                    compare_hir_and_ast_module(ast_module, hir_module, ctx).is_some()
                 } else {
                     let source_file_id = source.file_id.original_file(ctx.db());
-                    have_same_parent = source_file_id == curr_file_id;
+                    source_file_id == curr_file_id
                 }
             } else {
                 let source_file_id = source.file_id.original_file(ctx.db());
-                have_same_parent = source_file_id == curr_file_id;
-            }
+                source_file_id == curr_file_id
+            };
 
             if have_same_parent {
-                match source.value {
-                    ModuleSource::Module(module_) => {
-                        source_exists_outside_sel_in_same_mod =
-                            !selection_range.contains_range(module_.syntax().text_range());
-                    }
-                    _ => {}
+                if let ModuleSource::Module(module_) = source.value {
+                    source_exists_outside_sel_in_same_mod =
+                        !selection_range.contains_range(module_.syntax().text_range());
                 }
             }
         }
diff --git a/crates/ide-assists/src/handlers/generate_delegate_trait.rs b/crates/ide-assists/src/handlers/generate_delegate_trait.rs
@@ -270,19 +270,16 @@ fn generate_impl(
                 make::path_from_text(&format!("<{} as {}>", field_ty, delegate.trait_()?));
 
             let delegate_assoc_items = delegate.get_or_create_assoc_item_list();
-            match bound_def.assoc_item_list() {
-                Some(ai) => {
-                    ai.assoc_items()
-                        .filter(|item| matches!(item, AssocItem::MacroCall(_)).not())
-                        .for_each(|item| {
-                            let assoc =
-                                process_assoc_item(item, qualified_path_type.clone(), field_name);
-                            if let Some(assoc) = assoc {
-                                delegate_assoc_items.add_item(assoc);
-                            }
-                        });
-                }
-                None => {}
+            if let Some(ai) = bound_def.assoc_item_list() {
+                ai.assoc_items()
+                    .filter(|item| matches!(item, AssocItem::MacroCall(_)).not())
+                    .for_each(|item| {
+                        let assoc =
+                            process_assoc_item(item, qualified_path_type.clone(), field_name);
+                        if let Some(assoc) = assoc {
+                            delegate_assoc_items.add_item(assoc);
+                        }
+                    });
             };
 
             let target_scope = ctx.sema.scope(strukt.strukt.syntax())?;
@@ -512,17 +509,14 @@ fn generate_args_for_impl(
     // form the substitution list
     let mut arg_substs = FxHashMap::default();
 
-    match field_ty {
-        field_ty @ ast::Type::PathType(_) => {
-            let field_args = field_ty.generic_arg_list().map(|gal| gal.generic_args());
-            let self_ty_args = self_ty.generic_arg_list().map(|gal| gal.generic_args());
-            if let (Some(field_args), Some(self_ty_args)) = (field_args, self_ty_args) {
-                self_ty_args.zip(field_args).for_each(|(self_ty_arg, field_arg)| {
-                    arg_substs.entry(self_ty_arg.to_string()).or_insert(field_arg);
-                })
-            }
+    if let field_ty @ ast::Type::PathType(_) = field_ty {
+        let field_args = field_ty.generic_arg_list().map(|gal| gal.generic_args());
+        let self_ty_args = self_ty.generic_arg_list().map(|gal| gal.generic_args());
+        if let (Some(field_args), Some(self_ty_args)) = (field_args, self_ty_args) {
+            self_ty_args.zip(field_args).for_each(|(self_ty_arg, field_arg)| {
+                arg_substs.entry(self_ty_arg.to_string()).or_insert(field_arg);
+            })
         }
-        _ => {}
     }
 
     let args = old_impl_args
diff --git a/crates/ide-assists/src/handlers/generate_trait_from_impl.rs b/crates/ide-assists/src/handlers/generate_trait_from_impl.rs
@@ -181,21 +181,18 @@ fn remove_items_visibility(item: &ast::AssocItem) {
 }
 
 fn strip_body(item: &ast::AssocItem) {
-    match item {
-        ast::AssocItem::Fn(f) => {
-            if let Some(body) = f.body() {
-                // In constrast to function bodies, we want to see no ws before a semicolon.
-                // So let's remove them if we see any.
-                if let Some(prev) = body.syntax().prev_sibling_or_token() {
-                    if prev.kind() == SyntaxKind::WHITESPACE {
-                        ted::remove(prev);
-                    }
+    if let ast::AssocItem::Fn(f) = item {
+        if let Some(body) = f.body() {
+            // In constrast to function bodies, we want to see no ws before a semicolon.
+            // So let's remove them if we see any.
+            if let Some(prev) = body.syntax().prev_sibling_or_token() {
+                if prev.kind() == SyntaxKind::WHITESPACE {
+                    ted::remove(prev);
                 }
-
-                ted::replace(body.syntax(), make::tokens::semicolon());
             }
+
+            ted::replace(body.syntax(), make::tokens::semicolon());
         }
-        _ => (),
     };
 }
 
diff --git a/crates/ide-assists/src/handlers/inline_call.rs b/crates/ide-assists/src/handlers/inline_call.rs
@@ -425,8 +425,8 @@ fn inline(
             if is_self {
                 let mut this_pat = make::ident_pat(false, false, make::name("this"));
                 let mut expr = expr.clone();
-                match pat {
-                    Pat::IdentPat(pat) => match (pat.ref_token(), pat.mut_token()) {
+                if let Pat::IdentPat(pat) = pat {
+                    match (pat.ref_token(), pat.mut_token()) {
                         // self => let this = obj
                         (None, None) => {}
                         // mut self => let mut this = obj
@@ -449,8 +449,7 @@ fn inline(
                                 make::expr_ref(expr, true)
                             };
                         }
-                    },
-                    _ => {}
+                    }
                 };
                 let_stmts
                     .push(make::let_stmt(this_pat.into(), ty, Some(expr)).clone_for_update().into())
diff --git a/crates/ide-completion/src/completions/field.rs b/crates/ide-completion/src/completions/field.rs
@@ -11,22 +11,18 @@ pub(crate) fn complete_field_list_tuple_variant(
     path_ctx: &PathCompletionCtx,
 ) {
     if ctx.qualifier_ctx.vis_node.is_some() {
-        return;
-    }
-    match path_ctx {
-        PathCompletionCtx {
-            has_macro_bang: false,
-            qualified: Qualified::No,
-            parent: None,
-            has_type_args: false,
-            ..
-        } => {
-            let mut add_keyword = |kw, snippet| acc.add_keyword_snippet(ctx, kw, snippet);
-            add_keyword("pub(crate)", "pub(crate)");
-            add_keyword("pub(super)", "pub(super)");
-            add_keyword("pub", "pub");
-        }
-        _ => (),
+    } else if let PathCompletionCtx {
+        has_macro_bang: false,
+        qualified: Qualified::No,
+        parent: None,
+        has_type_args: false,
+        ..
+    } = path_ctx
+    {
+        let mut add_keyword = |kw, snippet| acc.add_keyword_snippet(ctx, kw, snippet);
+        add_keyword("pub(crate)", "pub(crate)");
+        add_keyword("pub(super)", "pub(super)");
+        add_keyword("pub", "pub");
     }
 }
 
diff --git a/crates/ide-completion/src/completions/flyimport.rs b/crates/ide-completion/src/completions/flyimport.rs
@@ -369,11 +369,10 @@ fn import_on_the_fly_method(
             };
             key(&a.import_path).cmp(&key(&b.import_path))
         })
-        .for_each(|import| match import.original_item {
-            ItemInNs::Values(hir::ModuleDef::Function(f)) => {
+        .for_each(|import| {
+            if let ItemInNs::Values(hir::ModuleDef::Function(f)) = import.original_item {
                 acc.add_method_with_import(ctx, dot_access, f, import);
             }
-            _ => (),
         });
     Some(())
 }
diff --git a/crates/ide-completion/src/render.rs b/crates/ide-completion/src/render.rs
@@ -295,15 +295,12 @@ fn render_resolution_pat(
     let _p = profile::span("render_resolution");
     use hir::ModuleDef::*;
 
-    match resolution {
-        ScopeDef::ModuleDef(Macro(mac)) => {
-            let ctx = ctx.import_to_add(import_to_add);
-            return render_macro_pat(ctx, pattern_ctx, local_name, mac);
-        }
-        _ => (),
+    if let ScopeDef::ModuleDef(Macro(mac)) = resolution {
+        let ctx = ctx.import_to_add(import_to_add);
+        render_macro_pat(ctx, pattern_ctx, local_name, mac)
+    } else {
+        render_resolution_simple_(ctx, &local_name, import_to_add, resolution)
     }
-
-    render_resolution_simple_(ctx, &local_name, import_to_add, resolution)
 }
 
 fn render_resolution_path(
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
@@ -282,8 +282,8 @@ fn traverse(
                 inside_attribute = false
             }
 
-            Enter(NodeOrToken::Node(node)) => match ast::Item::cast(node.clone()) {
-                Some(item) => {
+            Enter(NodeOrToken::Node(node)) => {
+                if let Some(item) = ast::Item::cast(node.clone()) {
                     match item {
                         ast::Item::MacroRules(mac) => {
                             macro_highlighter.init();
@@ -324,8 +324,7 @@ fn traverse(
                         }
                     }
                 }
-                _ => (),
-            },
+            }
             Leave(NodeOrToken::Node(node)) if ast::Item::can_cast(node.kind()) => {
                 match ast::Item::cast(node.clone()) {
                     Some(ast::Item::MacroRules(mac)) => {
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
@@ -567,10 +567,11 @@ impl GlobalState {
 
         for ws in &self.fetch_build_data_queue.last_op_result().1 {
             match ws {
-                Ok(data) => match data.error() {
-                    Some(stderr) => stdx::format_to!(buf, "{:#}\n", stderr),
-                    _ => (),
-                },
+                Ok(data) => {
+                    if let Some(stderr) = data.error() {
+                        stdx::format_to!(buf, "{:#}\n", stderr)
+                    }
+                }
                 // io errors
                 Err(err) => stdx::format_to!(buf, "{:#}\n", err),
             }

Original file line number	Diff line number	Diff line change
`@@ -142,13 +142,10 @@ impl HirPlace {`
`142`	`142`	`mut current_capture: CaptureKind,`
`143`	`143`	`len: usize,`
`144`	`144`	`) -> CaptureKind {`
`145`		`- match current_capture {`
`146`		`- CaptureKind::ByRef(BorrowKind::Mut { .. }) => {`
`147`		`- if self.projections[len..].iter().any(\|it\| *it == ProjectionElem::Deref) {`
`148`		`- current_capture = CaptureKind::ByRef(BorrowKind::Unique);`
`149`		`- }`
	`145`	`+ if let CaptureKind::ByRef(BorrowKind::Mut { .. }) = current_capture {`
	`146`	`+ if self.projections[len..].iter().any(\|it\| *it == ProjectionElem::Deref) {`
	`147`	`+ current_capture = CaptureKind::ByRef(BorrowKind::Unique);`
`150`	`148`	`}`
`151`		`- _ => (),`
`152`	`149`	`}`
`153`	`150`	`current_capture`
`154`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -339,11 +339,8 @@ fn push_mut_span(local: LocalId, span: MirSpan, result: &mut ArenaMap<LocalId, M`
`339`	`339`	`}`
`340`	`340`
`341`	`341`	`fn record_usage(local: LocalId, result: &mut ArenaMap<LocalId, MutabilityReason>) {`
`342`		`- match &mut result[local] {`
`343`		`- it @ MutabilityReason::Unused => {`
`344`		`- *it = MutabilityReason::Not;`
`345`		`- }`
`346`		`- _ => (),`
	`342`	`+ if let it @ MutabilityReason::Unused = &mut result[local] {`
	`343`	`+ *it = MutabilityReason::Not;`
`347`	`344`	`};`
`348`	`345`	`}`
`349`	`346`
Original file line number	Diff line number	Diff line change
`@@ -181,21 +181,18 @@ fn remove_items_visibility(item: &ast::AssocItem) {`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`fn strip_body(item: &ast::AssocItem) {`
`184`		`- match item {`
`185`		`- ast::AssocItem::Fn(f) => {`
`186`		`- if let Some(body) = f.body() {`
`187`		`- // In constrast to function bodies, we want to see no ws before a semicolon.`
`188`		`- // So let's remove them if we see any.`
`189`		`- if let Some(prev) = body.syntax().prev_sibling_or_token() {`
`190`		`- if prev.kind() == SyntaxKind::WHITESPACE {`
`191`		`- ted::remove(prev);`
`192`		`- }`
	`184`	`+ if let ast::AssocItem::Fn(f) = item {`
	`185`	`+ if let Some(body) = f.body() {`
	`186`	`+ // In constrast to function bodies, we want to see no ws before a semicolon.`
	`187`	`+ // So let's remove them if we see any.`
	`188`	`+ if let Some(prev) = body.syntax().prev_sibling_or_token() {`
	`189`	`+ if prev.kind() == SyntaxKind::WHITESPACE {`
	`190`	`+ ted::remove(prev);`
`193`	`191`	`}`
`194`		`-`
`195`		`- ted::replace(body.syntax(), make::tokens::semicolon());`
`196`	`192`	`}`
	`193`	`+`
	`194`	`+ ted::replace(body.syntax(), make::tokens::semicolon());`
`197`	`195`	`}`
`198`		`- _ => (),`
`199`	`196`	`};`
`200`	`197`	`}`
`201`	`198`