3 - Make more use of let_chains

Continuation of #94376.

cc #53667

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1921,9 +1921,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 err.span_label(assigned_span, format!("first assignment to {}", place_description));
             }
         }
-        if let Some(decl) = local_decl {
+        if let Some(decl) = local_decl
-            if let Some(name) = local_name {
+            && let Some(name) = local_name
-                if decl.can_be_made_mutable() {
+            && decl.can_be_made_mutable()
+        {
             err.span_suggestion(
                 decl.source_info.span,
                 "consider making this binding mutable",
@@ -1931,8 +1932,6 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 Applicability::MachineApplicable,
             );
         }
-            }
-        }
         err.span_label(span, msg);
         self.buffer_error(err);
     }

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -375,16 +375,13 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
             Some(Cause::DropVar(local, location)) => {
                 let mut should_note_order = false;
-                if self.local_names[local].is_some() {
+                if self.local_names[local].is_some()
-                    if let Some((WriteKind::StorageDeadOrDrop, place)) = kind_place {
+                    && let Some((WriteKind::StorageDeadOrDrop, place)) = kind_place
-                        if let Some(borrowed_local) = place.as_local() {
+                    && let Some(borrowed_local) = place.as_local()
-                            if self.local_names[borrowed_local].is_some() && local != borrowed_local
+                    && self.local_names[borrowed_local].is_some() && local != borrowed_local
                 {
                     should_note_order = true;
                 }
-                        }
-                    }
-                }
 
                 BorrowExplanation::UsedLaterWhenDropped {
                     drop_loc: location,

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -1086,21 +1086,17 @@ fn get_mut_span_in_struct_field<'tcx>(
     field: &mir::Field,
 ) -> Option<Span> {
     // Expect our local to be a reference to a struct of some kind.
-    if let ty::Ref(_, ty, _) = ty.kind() {
+    if let ty::Ref(_, ty, _) = ty.kind()
-        if let ty::Adt(def, _) = ty.kind() {
+        && let ty::Adt(def, _) = ty.kind()
-            let field = def.all_fields().nth(field.index())?;
+        && let field = def.all_fields().nth(field.index())?
         // Use the HIR types to construct the diagnostic message.
-            let node = tcx.hir().find_by_def_id(field.did.as_local()?)?;
+        && let node = tcx.hir().find_by_def_id(field.did.as_local()?)?
         // Now we're dealing with the actual struct that we're going to suggest a change to,
         // we can expect a field that is an immutable reference to a type.
-            if let hir::Node::Field(field) = node {
+        && let hir::Node::Field(field) = node
-                if let hir::TyKind::Rptr(lifetime, hir::MutTy { mutbl: hir::Mutability::Not, ty }) =
+        && let hir::TyKind::Rptr(lt, hir::MutTy { mutbl: hir::Mutability::Not, ty }) = field.ty.kind
-                    field.ty.kind
     {
-                    return Some(lifetime.span.between(ty.span));
+        return Some(lt.span.between(ty.span));
-                }
-            }
-        }
     }
 
     None

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -140,15 +140,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
 
     /// Returns `true` if a closure is inferred to be an `FnMut` closure.
     fn is_closure_fn_mut(&self, fr: RegionVid) -> bool {
-        if let Some(ty::ReFree(free_region)) = self.to_error_region(fr).as_deref() {
+        if let Some(ty::ReFree(free_region)) = self.to_error_region(fr).as_deref()
-            if let ty::BoundRegionKind::BrEnv = free_region.bound_region {
+            && let ty::BoundRegionKind::BrEnv = free_region.bound_region
-                if let DefiningTy::Closure(_, substs) =
+            && let DefiningTy::Closure(_, substs) = self.regioncx.universal_regions().defining_ty
-                    self.regioncx.universal_regions().defining_ty
         {
             return substs.as_closure().kind() == ty::ClosureKind::FnMut;
         }
-            }
-        }
 
         false
     }

compiler/rustc_borrowck/src/lib.rs

@@ -1,15 +1,16 @@
 //! This query borrow-checks the MIR to (further) ensure it is not broken.
 
+#![allow(rustc::potential_query_instability)]
 #![feature(bool_to_option)]
 #![feature(box_patterns)]
 #![feature(crate_visibility_modifier)]
+#![feature(let_chains)]
 #![feature(let_else)]
 #![feature(min_specialization)]
 #![feature(stmt_expr_attributes)]
 #![feature(trusted_step)]
 #![feature(try_blocks)]
 #![recursion_limit = "256"]
-#![allow(rustc::potential_query_instability)]
 
 #[macro_use]
 extern crate rustc_middle;
@@ -159,8 +160,7 @@ fn do_mir_borrowck<'a, 'tcx>(
     for var_debug_info in &input_body.var_debug_info {
         if let VarDebugInfoContents::Place(place) = var_debug_info.value {
             if let Some(local) = place.as_local() {
-                if let Some(prev_name) = local_names[local] {
+                if let Some(prev_name) = local_names[local] && var_debug_info.name != prev_name {
-                    if var_debug_info.name != prev_name {
                     span_bug!(
                         var_debug_info.source_info.span,
                         "local {:?} has many names (`{}` vs `{}`)",
@@ -169,7 +169,6 @@ fn do_mir_borrowck<'a, 'tcx>(
                         var_debug_info.name
                     );
                 }
-                }
                 local_names[local] = Some(var_debug_info.name);
             }
         }

compiler/rustc_borrowck/src/places_conflict.rs

@@ -60,11 +60,9 @@ pub(super) fn borrow_conflicts_with_place<'tcx>(
 
     // This Local/Local case is handled by the more general code below, but
     // it's so common that it's a speed win to check for it first.
-    if let Some(l1) = borrow_place.as_local() {
+    if let Some(l1) = borrow_place.as_local() && let Some(l2) = access_place.as_local() {
-        if let Some(l2) = access_place.as_local() {
         return l1 == l2;
     }
-    }
 
     place_components_conflict(tcx, body, borrow_place, borrow_kind, access_place, access, bias)
 }