fix some manual_map

Author: matthiaskrgr

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -959,13 +959,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         None
                     }
                 }
-                hir::ExprKind::MethodCall(_, _, args, span) => {
-                    if let Some(def_id) = typeck_results.type_dependent_def_id(*hir_id) {
-                        Some((def_id, *span, *args))
-                    } else {
-                        None
-                    }
-                }
+                hir::ExprKind::MethodCall(_, _, args, span) => typeck_results
+                    .type_dependent_def_id(*hir_id)
+                    .map(|def_id| (def_id, *span, *args)),
                 _ => None,
             }
         };

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -529,7 +529,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     && binding_id != self.binding_id
                 {
                     if self.check_and_add_sugg_binding(LetStmt {
-                        ty_hir_id_opt: if let Some(ty) = ty { Some(ty.hir_id) } else { None },
+                        ty_hir_id_opt: ty.map(|ty| ty.hir_id),
                         binding_id,
                         span: pat.span,
                         init_hir_id: init.hir_id,

compiler/rustc_lint/src/context/diagnostics/check_cfg.rs

@@ -234,14 +234,12 @@ pub(super) fn unexpected_cfg_value(
 
         let suggestion = if let Some((value, value_span)) = value {
             // Suggest the most probable if we found one
-            if let Some(best_match) = find_best_match_for_name(&possibilities, value, None) {
-                Some(lints::unexpected_cfg_value::ChangeValueSuggestion::SimilarName {
+            find_best_match_for_name(&possibilities, value, None).map(|best_match| {
+                lints::unexpected_cfg_value::ChangeValueSuggestion::SimilarName {
                     span: value_span,
                     best_match,
-                })
-            } else {
-                None
-            }
+                }
+            })
         } else if let &[first_possibility] = &possibilities[..] {
             Some(lints::unexpected_cfg_value::ChangeValueSuggestion::SpecifyValue {
                 span: name_span.shrink_to_hi(),

compiler/rustc_middle/src/mir/mod.rs

@@ -1482,10 +1482,10 @@ impl SourceScope {
         let scope_data = &source_scopes[self];
         if let Some((inlined_instance, _)) = scope_data.inlined {
             Some(inlined_instance)
-        } else if let Some(inlined_scope) = scope_data.inlined_parent_scope {
-            Some(source_scopes[inlined_scope].inlined.unwrap().0)
         } else {
-            None
+            scope_data
+                .inlined_parent_scope
+                .map(|inlined_scope| source_scopes[inlined_scope].inlined.unwrap().0)
         }
     }
 }

compiler/rustc_middle/src/ty/inhabitedness/inhabited_predicate.rs

@@ -190,10 +190,8 @@ impl<'tcx> InhabitedPredicate<'tcx> {
             (Self::And(&[a, b]), c) | (c, Self::And(&[a, b])) => {
                 if let Some(ac) = a.reduce_and(tcx, c) {
                     Some(ac.and(tcx, b))
-                } else if let Some(bc) = b.reduce_and(tcx, c) {
-                    Some(Self::And(tcx.arena.alloc([a, bc])))
                 } else {
-                    None
+                    b.reduce_and(tcx, c).map(|bc| Self::And(tcx.arena.alloc([a, bc])))
                 }
             }
             _ => None,
@@ -216,10 +214,8 @@ impl<'tcx> InhabitedPredicate<'tcx> {
             (Self::Or(&[a, b]), c) | (c, Self::Or(&[a, b])) => {
                 if let Some(ac) = a.reduce_or(tcx, c) {
                     Some(ac.or(tcx, b))
-                } else if let Some(bc) = b.reduce_or(tcx, c) {
-                    Some(Self::Or(tcx.arena.alloc([a, bc])))
                 } else {
-                    None
+                    b.reduce_or(tcx, c).map(|bc| Self::Or(tcx.arena.alloc([a, bc])))
                 }
             }
             _ => None,

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -224,14 +224,12 @@ fn find_similar_kw(lookup: Ident, candidates: &[Symbol]) -> Option<MisspelledKw>
     let lowercase_sym = Symbol::intern(&lowercase);
     if candidates.contains(&lowercase_sym) {
         Some(MisspelledKw { similar_kw: lowercase, span: lookup.span, is_incorrect_case: true })
-    } else if let Some(similar_sym) = find_best_match_for_name(candidates, lookup.name, None) {
-        Some(MisspelledKw {
+    } else {
+        find_best_match_for_name(candidates, lookup.name, None).map(|similar_sym| MisspelledKw {
             similar_kw: similar_sym.to_string(),
             span: lookup.span,
             is_incorrect_case: false,
         })
-    } else {
-        None
     }
 }
 

compiler/rustc_ty_utils/src/abi.rs

@@ -394,11 +394,11 @@ fn adjust_for_rust_scalar<'tcx>(
     if let Some(pointee) = layout.pointee_info_at(&cx, offset) {
         let kind = if let Some(kind) = pointee.safe {
             Some(kind)
-        } else if let Some(pointee) = drop_target_pointee {
-            // The argument to `drop_in_place` is semantically equivalent to a mutable reference.
-            Some(PointerKind::MutableRef { unpin: pointee.is_unpin(tcx, cx.param_env()) })
         } else {
-            None
+            // The argument to `drop_in_place` is semantically equivalent to a mutable reference.
+            drop_target_pointee.map(|pointee| PointerKind::MutableRef {
+                unpin: pointee.is_unpin(tcx, cx.param_env()),
+            })
         };
         if let Some(kind) = kind {
             attrs.pointee_align = Some(pointee.align);