Fix lint

Author: estebank

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -930,9 +930,8 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             return;
         };
 
-        let param = match find_param_with_region(tcx, self.mir_def_id(), f, o) {
-            Some(param) => param,
-            None => return,
+        let Some(param) = find_param_with_region(tcx, self.mir_def_id(), f, o) else {
+            return;
         };
         debug!(?param);
 

compiler/rustc_borrowck/src/polonius/legacy/accesses.rs

@@ -67,12 +67,11 @@ impl<'a, 'tcx> Visitor<'tcx> for AccessFactsExtractor<'a, 'tcx> {
         match context {
             PlaceContext::NonMutatingUse(_)
             | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
-                let path = match self.move_data.rev_lookup.find(place.as_ref()) {
-                    LookupResult::Exact(path) | LookupResult::Parent(Some(path)) => path,
-                    _ => {
-                        // There's no path access to emit.
-                        return;
-                    }
+                let (LookupResult::Exact(path) | LookupResult::Parent(Some(path))) =
+                    self.move_data.rev_lookup.find(place.as_ref())
+                else {
+                    // There's no path access to emit.
+                    return;
                 };
                 debug!("AccessFactsExtractor - emit path access ({path:?}, {location:?})");
                 self.facts.path_accessed_at_base.push((path, self.location_to_index(location)));

compiler/rustc_hir_analysis/src/collect.rs

@@ -1551,15 +1551,15 @@ fn const_param_default<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
 ) -> ty::EarlyBinder<'tcx, Const<'tcx>> {
-    let default_ct = match tcx.hir_node_by_def_id(def_id) {
-        hir::Node::GenericParam(hir::GenericParam {
-            kind: hir::GenericParamKind::Const { default: Some(ct), .. },
-            ..
-        }) => ct,
-        _ => span_bug!(
+    let hir::Node::GenericParam(hir::GenericParam {
+        kind: hir::GenericParamKind::Const { default: Some(default_ct), .. },
+        ..
+    }) = tcx.hir_node_by_def_id(def_id)
+    else {
+        span_bug!(
             tcx.def_span(def_id),
             "`const_param_default` expected a generic parameter with a constant"
-        ),
+        )
     };
     let icx = ItemCtxt::new(tcx, def_id);
     let identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);

compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs

@@ -763,9 +763,8 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
         &self,
         err: &mut Diag<'_, impl EmissionGuarantee>,
     ) {
-        let trait_ = match self.tcx.trait_of_assoc(self.def_id) {
-            Some(def_id) => def_id,
-            None => return,
+        let Some(trait_) = self.tcx.trait_of_assoc(self.def_id) else {
+            return;
         };
 
         // Skip suggestion when the associated function is itself generic, it is unclear

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -1561,19 +1561,15 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
         base_place: PlaceWithHirId<'tcx>,
     ) -> Result<PlaceWithHirId<'tcx>, Cx::Error> {
         let base_curr_ty = base_place.place.ty();
-        let deref_ty = match self
+        let Some(deref_ty) = self
             .cx
             .structurally_resolve_type(self.cx.tcx().hir_span(base_place.hir_id), base_curr_ty)
             .builtin_deref(true)
-        {
-            Some(ty) => ty,
-            None => {
-                debug!("explicit deref of non-derefable type: {:?}", base_curr_ty);
-                return Err(self.cx.report_bug(
-                    self.cx.tcx().hir_span(node),
-                    "explicit deref of non-derefable type",
-                ));
-            }
+        else {
+            debug!("explicit deref of non-derefable type: {:?}", base_curr_ty);
+            return Err(self
+                .cx
+                .report_bug(self.cx.tcx().hir_span(node), "explicit deref of non-derefable type"));
         };
         let mut projections = base_place.place.projections;
         projections.push(Projection { kind: ProjectionKind::Deref, ty: deref_ty });

compiler/rustc_middle/src/ty/mod.rs

@@ -2405,9 +2405,7 @@ fn typetree_from_ty_impl_inner<'tcx>(
     }
 
     if ty.is_ref() || ty.is_raw_ptr() || ty.is_box() {
-        let inner_ty = if let Some(inner) = ty.builtin_deref(true) {
-            inner
-        } else {
+        let Some(inner_ty) = ty.builtin_deref(true) else {
             return TypeTree::new();
         };
 

compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs

@@ -445,17 +445,15 @@ where
         goal_kind: ty::ClosureKind,
     ) -> Result<Candidate<I>, NoSolution> {
         let cx = ecx.cx();
-        let tupled_inputs_and_output =
-            match structural_traits::extract_tupled_inputs_and_output_from_callable(
+        let Some(tupled_inputs_and_output) =
+            structural_traits::extract_tupled_inputs_and_output_from_callable(
                 cx,
                 goal.predicate.self_ty(),
                 goal_kind,
-            )? {
-                Some(tupled_inputs_and_output) => tupled_inputs_and_output,
-                None => {
-                    return ecx.forced_ambiguity(MaybeCause::Ambiguity);
-                }
-            };
+            )?
+        else {
+            return ecx.forced_ambiguity(MaybeCause::Ambiguity);
+        };
         let (inputs, output) = ecx.instantiate_binder_with_infer(tupled_inputs_and_output);
 
         // A built-in `Fn` impl only holds if the output is sized.

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -360,17 +360,15 @@ where
         }
 
         let cx = ecx.cx();
-        let tupled_inputs_and_output =
-            match structural_traits::extract_tupled_inputs_and_output_from_callable(
+        let Some(tupled_inputs_and_output) =
+            structural_traits::extract_tupled_inputs_and_output_from_callable(
                 cx,
                 goal.predicate.self_ty(),
                 goal_kind,
-            )? {
-                Some(a) => a,
-                None => {
-                    return ecx.forced_ambiguity(MaybeCause::Ambiguity);
-                }
-            };
+            )?
+        else {
+            return ecx.forced_ambiguity(MaybeCause::Ambiguity);
+        };
         let (inputs, output) = ecx.instantiate_binder_with_infer(tupled_inputs_and_output);
 
         // A built-in `Fn` impl only holds if the output is sized.