Format the world (considering let-chains)

Author: compiler-errors

compiler/rustc_ast/src/attr/mod.rs

@@ -595,9 +595,7 @@ impl NestedMetaItem {
         I: Iterator<Item = TokenTree>,
     {
         match tokens.peek() {
-            Some(TokenTree::Token(token))
-                if let Ok(lit) = Lit::from_token(token) =>
-            {
+            Some(TokenTree::Token(token)) if let Ok(lit) = Lit::from_token(token) => {
                 tokens.next();
                 return Some(NestedMetaItem::Literal(lit));
             }

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1003,8 +1003,10 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
     }
 
     fn visit_expr(&mut self, expr: &'a Expr) {
-        self.with_let_management(Some(ForbiddenLetReason::GenericForbidden), |this, forbidden_let_reason| {
-            match &expr.kind {
+        self.with_let_management(
+            Some(ForbiddenLetReason::GenericForbidden),
+            |this, forbidden_let_reason| {
+                match &expr.kind {
                 ExprKind::Binary(Spanned { node: BinOpKind::Or, span }, lhs, rhs) => {
                     let forbidden_let_reason = Some(ForbiddenLetReason::ForbiddenWithOr(*span));
                     this.with_let_management(forbidden_let_reason, |this, _| this.visit_expr(lhs));
@@ -1018,23 +1020,25 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 }
                 ExprKind::Let(..) if let Some(elem) = forbidden_let_reason => {
                     this.ban_let_expr(expr, elem);
-                },
+                }
                 ExprKind::Match(scrutinee, arms) => {
                     this.visit_expr(scrutinee);
                     for arm in arms {
                         this.visit_expr(&arm.body);
                         this.visit_pat(&arm.pat);
                         walk_list!(this, visit_attribute, &arm.attrs);
-                        if let Some(guard) = &arm.guard && let ExprKind::Let(_, guard_expr, _) = &guard.kind {
-                            this.with_let_management(None, |this, _| {
-                                this.visit_expr(guard_expr)
-                            });
+                        if let Some(guard) = &arm.guard
+                            && let ExprKind::Let(_, guard_expr, _) = &guard.kind
+                        {
+                            this.with_let_management(None, |this, _| this.visit_expr(guard_expr));
                             return;
                         }
                     }
                 }
                 ExprKind::Paren(_) | ExprKind::Binary(Spanned { node: BinOpKind::And, .. }, ..) => {
-                    this.with_let_management(forbidden_let_reason, |this, _| visit::walk_expr(this, expr));
+                    this.with_let_management(forbidden_let_reason, |this, _| {
+                        visit::walk_expr(this, expr)
+                    });
                     return;
                 }
                 ExprKind::While(cond, then, opt_label) => {
@@ -1045,7 +1049,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 }
                 _ => visit::walk_expr(this, expr),
             }
-        });
+            },
+        );
     }
 
     fn visit_ty(&mut self, ty: &'a Ty) {

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1840,9 +1840,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 err.span_label(assigned_span, format!("first assignment to {}", place_description));
             }
         }
-        if let Some(decl) = local_decl
-            && let Some(name) = local_name
-            && decl.can_be_made_mutable()
+        if let Some(decl) = local_decl && let Some(name) = local_name && decl.can_be_made_mutable()
         {
             err.span_suggestion(
                 decl.source_info.span,

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -378,7 +378,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 if self.local_names[local].is_some()
                     && let Some((WriteKind::StorageDeadOrDrop, place)) = kind_place
                     && let Some(borrowed_local) = place.as_local()
-                    && self.local_names[borrowed_local].is_some() && local != borrowed_local
+                    && self.local_names[borrowed_local].is_some()
+                    && local != borrowed_local
                 {
                     should_note_order = true;
                 }

compiler/rustc_expand/src/config.rs

@@ -290,7 +290,8 @@ impl<'a> StripUnconfigured<'a> {
         let trees: Vec<_> = stream
             .0
             .iter()
-            .flat_map(|(tree, spacing)| match tree.clone() {
+            .flat_map(|(tree, spacing)| {
+                match tree.clone() {
                 AttrAnnotatedTokenTree::Attributes(mut data) => {
                     let mut attrs: Vec<_> = std::mem::take(&mut data.attrs).into();
                     attrs.flat_map_in_place(|attr| self.process_cfg_attr(attr));
@@ -310,15 +311,15 @@ impl<'a> StripUnconfigured<'a> {
                     Some((AttrAnnotatedTokenTree::Delimited(sp, delim, inner), *spacing))
                         .into_iter()
                 }
-                AttrAnnotatedTokenTree::Token(ref token) if let TokenKind::Interpolated(ref nt) = token.kind => {
-                    panic!(
-                        "Nonterminal should have been flattened at {:?}: {:?}",
-                        token.span, nt
-                    );
+                AttrAnnotatedTokenTree::Token(ref token)
+                    if let TokenKind::Interpolated(ref nt) = token.kind =>
+                {
+                    panic!("Nonterminal should have been flattened at {:?}: {:?}", token.span, nt);
                 }
                 AttrAnnotatedTokenTree::Token(token) => {
                     Some((AttrAnnotatedTokenTree::Token(token), *spacing)).into_iter()
                 }
+            }
             })
             .collect();
         AttrAnnotatedTokenStream::new(trees)

compiler/rustc_expand/src/mbe/metavar_expr.rs

@@ -115,8 +115,7 @@ fn parse_depth<'sess>(
         && let Ok(n_usize) = usize::try_from(n_u128)
     {
         Ok(n_usize)
-    }
-    else {
+    } else {
         let msg = "only unsuffixes integer literals are supported in meta-variable expressions";
         Err(sess.span_diagnostic.struct_span_err(span, msg))
     }

compiler/rustc_expand/src/module.rs

@@ -87,7 +87,9 @@ crate fn mod_dir_path(
     inline: Inline,
 ) -> (PathBuf, DirOwnership) {
     match inline {
-        Inline::Yes if let Some(file_path) = mod_file_path_from_attr(sess, attrs, &module.dir_path) => {
+        Inline::Yes
+            if let Some(file_path) = mod_file_path_from_attr(sess, attrs, &module.dir_path) =>
+        {
             // For inline modules file path from `#[path]` is actually the directory path
             // for historical reasons, so we don't pop the last segment here.
             (file_path, DirOwnership::Owned { relative: None })

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -607,7 +607,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     err.span_label(span, format!("this expression has type `{}`", ty));
                 }
                 if let Some(ty::error::ExpectedFound { found, .. }) = exp_found
-                    && ty.is_box() && ty.boxed_ty() == found
+                    && ty.is_box()
+                    && ty.boxed_ty() == found
                     && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span)
                 {
                     err.span_suggestion(
@@ -2047,7 +2048,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                         // specify a character literal (issue #92479)
                         (ty::Char, ty::Ref(_, r, _)) if r.is_str() => {
                             if let Ok(code) = self.tcx.sess().source_map().span_to_snippet(span)
-                                && let Some(code) = code.strip_prefix('"').and_then(|s| s.strip_suffix('"'))
+                                && let Some(code) =
+                                    code.strip_prefix('"').and_then(|s| s.strip_suffix('"'))
                                 && code.chars().count() == 1
                             {
                                 err.span_suggestion(

compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs

@@ -124,12 +124,13 @@ impl<'a, 'tcx> Visitor<'tcx> for FindHirNodeVisitor<'a, 'tcx> {
         }
         if let ExprKind::MethodCall(segment, exprs, _) = expr.kind
             && segment.ident.span == self.target_span
-            && Some(self.target) == self.infcx.in_progress_typeck_results.and_then(|typeck_results| {
-                typeck_results
-                    .borrow()
-                    .node_type_opt(exprs.first().unwrap().hir_id)
-                    .map(Into::into)
-            })
+            && Some(self.target)
+                == self.infcx.in_progress_typeck_results.and_then(|typeck_results| {
+                    typeck_results
+                        .borrow()
+                        .node_type_opt(exprs.first().unwrap().hir_id)
+                        .map(Into::into)
+                })
         {
             self.found_exact_method_call = Some(&expr);
             return;
@@ -731,17 +732,15 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 //    |               help: specify type like: `<Impl as Into<u32>>::into(foo_impl)`
                 //    |
                 //    = note: cannot satisfy `Impl: Into<_>`
-                if !impl_candidates.is_empty() && e.span.contains(span)
+                if !impl_candidates.is_empty()
+                    && e.span.contains(span)
                     && let Some(expr) = exprs.first()
                     && let ExprKind::Path(hir::QPath::Resolved(_, path)) = expr.kind
                     && let [path_segment] = path.segments
                 {
                     let candidate_len = impl_candidates.len();
                     let suggestions = impl_candidates.iter().map(|candidate| {
-                        format!(
-                            "{}::{}({})",
-                            candidate, segment.ident, path_segment.ident
-                        )
+                        format!("{}::{}({})", candidate, segment.ident, path_segment.ident)
                     });
                     err.span_suggestions(
                         e.span,

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

@@ -237,7 +237,8 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                 ObligationCauseCode::MatchImpl(parent, ..) => parent.code(),
                 _ => cause.code(),
             }
-            && let (ObligationCauseCode::ItemObligation(item_def_id), None) = (code, override_error_code)
+            && let (ObligationCauseCode::ItemObligation(item_def_id), None) =
+                (code, override_error_code)
         {
             // Same case of `impl Foo for dyn Bar { fn qux(&self) {} }` introducing a `'static`
             // lifetime as above, but called using a fully-qualified path to the method: