Rollup merge of #110398 - matthiaskrgr:clippy_match, r=Nilstrieb,fee1-dead

use matches! macro in more places

r? `@Nilstrieb`

compiler/rustc_ast/src/ast.rs

@@ -1298,7 +1298,8 @@ impl Expr {
 
     /// To a first-order approximation, is this a pattern?
     pub fn is_approximately_pattern(&self) -> bool {
-        match &self.peel_parens().kind {
+        matches!(
+            &self.peel_parens().kind,
             ExprKind::Array(_)
                 | ExprKind::Call(_, _)
                 | ExprKind::Tup(_)
@@ -1306,9 +1307,8 @@ impl Expr {
                 | ExprKind::Range(_, _, _)
                 | ExprKind::Underscore
                 | ExprKind::Path(_, _)
-            | ExprKind::Struct(_) => true,
+                | ExprKind::Struct(_)
-            _ => false,
+        )
-        }
     }
 }
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -332,10 +332,7 @@ enum FnDeclKind {
 
 impl FnDeclKind {
     fn param_impl_trait_allowed(&self) -> bool {
-        match self {
+        matches!(self, FnDeclKind::Fn | FnDeclKind::Inherent | FnDeclKind::Impl | FnDeclKind::Trait)
-            FnDeclKind::Fn | FnDeclKind::Inherent | FnDeclKind::Impl | FnDeclKind::Trait => true,
-            _ => false,
-        }
     }
 
     fn return_impl_trait_allowed(&self, tcx: TyCtxt<'_>) -> bool {

compiler/rustc_hir/src/def.rs

@@ -234,10 +234,7 @@ impl DefKind {
 
     #[inline]
     pub fn is_fn_like(self) -> bool {
-        match self {
+        matches!(self, DefKind::Fn | DefKind::AssocFn | DefKind::Closure | DefKind::Generator)
-            DefKind::Fn | DefKind::AssocFn | DefKind::Closure | DefKind::Generator => true,
-            _ => false,
-        }
     }
 
     /// Whether `query get_codegen_attrs` should be used with this definition.

compiler/rustc_hir_analysis/src/collect.rs

@@ -1457,10 +1457,7 @@ fn compute_sig_of_foreign_fn_decl<'tcx>(
 }
 
 fn is_foreign_item(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
-    match tcx.hir().get_by_def_id(def_id) {
+    matches!(tcx.hir().get_by_def_id(def_id), Node::ForeignItem(..))
-        Node::ForeignItem(..) => true,
-        _ => false,
-    }
 }
 
 fn generator_kind(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<hir::GeneratorKind> {

compiler/rustc_hir_typeck/src/expr.rs

@@ -1735,10 +1735,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             } else {
                 self.check_expr_has_type_or_error(base_expr, adt_ty, |_| {
                     let base_ty = self.typeck_results.borrow().expr_ty(*base_expr);
-                    let same_adt = match (adt_ty.kind(), base_ty.kind()) {
+                    let same_adt = matches!((adt_ty.kind(), base_ty.kind()),
-                        (ty::Adt(adt, _), ty::Adt(base_adt, _)) if adt == base_adt => true,
+                        (ty::Adt(adt, _), ty::Adt(base_adt, _)) if adt == base_adt);
-                        _ => false,
-                    };
                     if self.tcx.sess.is_nightly_build() && same_adt {
                         feature_err(
                             &self.tcx.sess.parse_sess,

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs

@@ -312,13 +312,10 @@ pub fn suggest_new_region_bound(
                             Applicability::MaybeIncorrect,
                         );
                     }
-                } else if opaque.bounds.iter().any(|arg| match arg {
+                } else if opaque.bounds.iter().any(|arg| {
+                    matches!(arg,
                         GenericBound::Outlives(Lifetime { ident, .. })
-                        if ident.name.to_string() == lifetime_name =>
+                        if ident.name.to_string() == lifetime_name )
-                    {
-                        true
-                    }
-                    _ => false,
                 }) {
                 } else {
                     // get a lifetime name of existing named lifetimes if any

compiler/rustc_infer/src/infer/mod.rs

@@ -1577,10 +1577,10 @@ impl<'tcx> InferCtxt<'tcx> {
             (TyOrConstInferVar::Ty(ty_var), Ok(inner)) => {
                 use self::type_variable::TypeVariableValue;
 
-                match inner.try_type_variables_probe_ref(ty_var) {
+                matches!(
-                    Some(TypeVariableValue::Unknown { .. }) => true,
+                    inner.try_type_variables_probe_ref(ty_var),
-                    _ => false,
+                    Some(TypeVariableValue::Unknown { .. })
-                }
+                )
             }
             _ => false,
         };

compiler/rustc_infer/src/traits/mod.rs

@@ -89,10 +89,10 @@ impl<'tcx> PredicateObligation<'tcx> {
 impl<'tcx> TraitObligation<'tcx> {
     /// Returns `true` if the trait predicate is considered `const` in its ParamEnv.
     pub fn is_const(&self) -> bool {
-        match (self.predicate.skip_binder().constness, self.param_env.constness()) {
+        matches!(
-            (ty::BoundConstness::ConstIfConst, hir::Constness::Const) => true,
+            (self.predicate.skip_binder().constness, self.param_env.constness()),
-            _ => false,
+            (ty::BoundConstness::ConstIfConst, hir::Constness::Const)
-        }
+        )
     }
 
     pub fn derived_cause(

compiler/rustc_mir_build/src/errors.rs

@@ -384,13 +384,8 @@ impl<'a> IntoDiagnostic<'a> for NonExhaustivePatternsTypeNotEmpty<'_, '_, '_> {
             diag.span_note(span, fluent::mir_build_def_note);
         }
 
-        let is_variant_list_non_exhaustive = match self.ty.kind() {
+        let is_variant_list_non_exhaustive = matches!(self.ty.kind(),
-            ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local() => {
+            ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local());
-                true
-            }
-            _ => false,
-        };
-
         if is_variant_list_non_exhaustive {
             diag.note(fluent::mir_build_non_exhaustive_type_note);
         } else {

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -671,10 +671,8 @@ fn non_exhaustive_match<'p, 'tcx>(
         };
     };
 
-    let is_variant_list_non_exhaustive = match scrut_ty.kind() {
+    let is_variant_list_non_exhaustive = matches!(scrut_ty.kind(),
-        ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local() => true,
+        ty::Adt(def, _) if def.is_variant_list_non_exhaustive() && !def.did().is_local());
-        _ => false,
-    };
 
     adt_defined_here(cx, &mut err, scrut_ty, &witnesses);
     err.note(&format!(

compiler/rustc_parse/src/parser/item.rs

@@ -2577,14 +2577,12 @@ impl<'a> Parser<'a> {
     }
 
     fn recover_self_param(&mut self) -> bool {
-        match self
+        matches!(
-            .parse_outer_attributes()
+            self.parse_outer_attributes()
                 .and_then(|_| self.parse_self_param())
-            .map_err(|e| e.cancel())
+                .map_err(|e| e.cancel()),
-        {
+            Ok(Some(_))
-            Ok(Some(_)) => true,
+        )
-            _ => false,
-        }
     }
 }
 

compiler/rustc_parse/src/parser/nonterminal.rs

@@ -20,12 +20,10 @@ impl<'a> Parser<'a> {
     pub fn nonterminal_may_begin_with(kind: NonterminalKind, token: &Token) -> bool {
         /// Checks whether the non-terminal may contain a single (non-keyword) identifier.
         fn may_be_ident(nt: &token::Nonterminal) -> bool {
-            match *nt {
+            !matches!(
-                token::NtItem(_) | token::NtBlock(_) | token::NtVis(_) | token::NtLifetime(_) => {
+                *nt,
-                    false
+                token::NtItem(_) | token::NtBlock(_) | token::NtVis(_) | token::NtLifetime(_)
-                }
+            )
-                _ => true,
-            }
         }
 
         match kind {

compiler/rustc_resolve/src/diagnostics.rs

@@ -663,15 +663,17 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                         Ident::with_dummy_span(name),
                         Namespace::ValueNS,
                         &parent_scope,
-                        &|res: Res| match res {
+                        &|res: Res| {
+                            matches!(
+                                res,
                                 Res::Def(
                                     DefKind::Ctor(CtorOf::Variant, CtorKind::Const)
                                         | DefKind::Ctor(CtorOf::Struct, CtorKind::Const)
                                         | DefKind::Const
                                         | DefKind::AssocConst,
                                     _,
-                            ) => true,
+                                )
-                            _ => false,
+                            )
                         },
                     );