revert clippy formating

Author: ABouttefeux

src/tools/clippy/clippy_lints/src/doc.rs

@@ -1,8 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{
-    is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty,
-};
+use clippy_utils::{is_entrypoint_fn, is_expn_of, match_panic_def_id, method_chain_args, return_ty};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{Async, AttrKind, Attribute, FnKind, FnRetTy, ItemKind};
@@ -197,7 +195,10 @@ pub struct DocMarkdown {
 
 impl DocMarkdown {
     pub fn new(valid_idents: FxHashSet<String>) -> Self {
-        Self { valid_idents, in_trait_impl: false }
+        Self {
+            valid_idents,
+            in_trait_impl: false,
+        }
     }
 }
 
@@ -216,9 +217,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
         let headers = check_attrs(cx, &self.valid_idents, attrs);
         match item.kind {
             hir::ItemKind::Fn(ref sig, _, body_id) => {
-                if !(is_entrypoint_fn(cx, item.def_id.to_def_id())
-                    || in_external_macro(cx.tcx.sess, item.span))
-                {
+                if !(is_entrypoint_fn(cx, item.def_id.to_def_id()) || in_external_macro(cx.tcx.sess, item.span)) {
                     let body = cx.tcx.hir().body(body_id);
                     let mut fpu = FindPanicUnwrap {
                         cx,
@@ -236,11 +235,11 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
                         fpu.panic_span,
                     );
                 }
-            }
+            },
             hir::ItemKind::Impl(ref impl_) => {
                 self.in_trait_impl = impl_.of_trait.is_some();
-            }
-            _ => {}
+            },
+            _ => {},
         }
     }
 
@@ -300,7 +299,12 @@ fn lint_for_missing_headers<'tcx>(
         return; // Private functions do not require doc comments
     }
     if !headers.safety && sig.header.unsafety == hir::Unsafety::Unsafe {
-        span_lint(cx, MISSING_SAFETY_DOC, span, "unsafe function's docs miss `# Safety` section");
+        span_lint(
+            cx,
+            MISSING_SAFETY_DOC,
+            span,
+            "unsafe function's docs miss `# Safety` section",
+        );
     }
     if !headers.panics && panic_span.is_some() {
         span_lint_and_note(
@@ -353,11 +357,7 @@ fn lint_for_missing_headers<'tcx>(
 /// the spans but this function is inspired from the later.
 #[allow(clippy::cast_possible_truncation)]
 #[must_use]
-pub fn strip_doc_comment_decoration(
-    doc: &str,
-    comment_kind: CommentKind,
-    span: Span,
-) -> (String, Vec<(usize, Span)>) {
+pub fn strip_doc_comment_decoration(doc: &str, comment_kind: CommentKind, span: Span) -> (String, Vec<(usize, Span)>) {
     // one-line comments lose their prefix
     if comment_kind == CommentKind::Line {
         let mut doc = doc.to_owned();
@@ -405,24 +405,23 @@ struct DocHeaders {
     panics: bool,
 }
 
-fn check_attrs<'a>(
-    cx: &LateContext<'_>,
-    valid_idents: &FxHashSet<String>,
-    attrs: &'a [Attribute],
-) -> DocHeaders {
+fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &'a [Attribute]) -> DocHeaders {
     let mut doc = String::new();
     let mut spans = vec![];
 
     for attr in attrs {
         if let AttrKind::DocComment(comment_kind, comment) = attr.kind {
-            let (comment, current_spans) =
-                strip_doc_comment_decoration(&comment.as_str(), comment_kind, attr.span);
+            let (comment, current_spans) = strip_doc_comment_decoration(&comment.as_str(), comment_kind, attr.span);
             spans.extend_from_slice(&current_spans);
             doc.push_str(&comment);
         } else if attr.has_name(sym::doc) {
             // ignore mix of sugared and non-sugared doc
             // don't trigger the safety or errors check
-            return DocHeaders { safety: true, errors: true, panics: true };
+            return DocHeaders {
+                safety: true,
+                errors: true,
+                panics: true,
+            };
         }
     }
 
@@ -434,7 +433,11 @@ fn check_attrs<'a>(
     }
 
     if doc.is_empty() {
-        return DocHeaders { safety: false, errors: false, panics: false };
+        return DocHeaders {
+            safety: false,
+            errors: false,
+            panics: false,
+        };
     }
 
     let parser = pulldown_cmark::Parser::new(&doc).into_offset_iter();
@@ -450,7 +453,7 @@ fn check_attrs<'a>(
                 let mut previous = previous.to_string();
                 previous.push_str(&current);
                 Ok((Text(previous.into()), previous_range))
-            }
+            },
             (previous, current) => Err(((previous, previous_range), (current, current_range))),
         }
     });
@@ -472,7 +475,11 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     };
     use pulldown_cmark::Tag::{CodeBlock, Heading, Link};
 
-    let mut headers = DocHeaders { safety: false, errors: false, panics: false };
+    let mut headers = DocHeaders {
+        safety: false,
+        errors: false,
+        panics: false,
+    };
     let mut in_code = false;
     let mut in_link = None;
     let mut in_heading = false;
@@ -496,11 +503,11 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                         }
                     }
                 }
-            }
+            },
             End(CodeBlock(_)) => {
                 in_code = false;
                 is_rust = false;
-            }
+            },
             Start(Link(_, url, _)) => in_link = Some(url),
             End(Link(..)) => in_link = None,
             Start(Heading(_)) => in_heading = true,
@@ -534,7 +541,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
 
                     check_text(cx, valid_idents, &text, span);
                 }
-            }
+            },
         }
     }
     headers
@@ -547,21 +554,19 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
                 let filename = FileName::anon_source_code(code);
 
                 let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
-                let emitter =
-                    EmitterWriter::new(box io::sink(), None, false, false, false, None, false);
+                let emitter = EmitterWriter::new(box io::sink(), None, false, false, false, None, false);
                 let handler = Handler::with_emitter(false, None, box emitter);
                 let sess = ParseSess::with_span_handler(handler, sm);
 
-                let mut parser =
-                    match maybe_new_parser_from_source_str(&sess, filename, code.into()) {
-                        Ok(p) => p,
-                        Err(errs) => {
-                            for mut err in errs {
-                                err.cancel();
-                            }
-                            return false;
+                let mut parser = match maybe_new_parser_from_source_str(&sess, filename, code.into()) {
+                    Ok(p) => p,
+                    Err(errs) => {
+                        for mut err in errs {
+                            err.cancel();
                         }
-                    };
+                        return false;
+                    },
+                };
 
                 let mut relevant_main_found = false;
                 loop {
@@ -573,9 +578,7 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
                             | ItemKind::ExternCrate(..)
                             | ItemKind::ForeignMod(..) => return false,
                             // We found a main function ...
-                            ItemKind::Fn(box FnKind(_, sig, _, Some(block)))
-                                if item.ident.name == sym::main =>
-                            {
+                            ItemKind::Fn(box FnKind(_, sig, _, Some(block))) if item.ident.name == sym::main => {
                                 let is_async = matches!(sig.header.asyncness, Async::Yes { .. });
                                 let returns_nothing = match &sig.decl.output {
                                     FnRetTy::Default(..) => true,
@@ -590,16 +593,16 @@ fn check_code(cx: &LateContext<'_>, text: &str, edition: Edition, span: Span) {
                                     // This main function should not be linted, we're done
                                     return false;
                                 }
-                            }
+                            },
                             // Another function was found; this case is ignored too
                             ItemKind::Fn(..) => return false,
-                            _ => {}
+                            _ => {},
                         },
                         Ok(None) => break,
                         Err(mut e) => {
                             e.cancel();
                             return false;
-                        }
+                        },
                     }
                 }
 
@@ -719,9 +722,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
         }
 
         // check for `assert_eq` or `assert_ne`
-        if is_expn_of(expr.span, "assert_eq").is_some()
-            || is_expn_of(expr.span, "assert_ne").is_some()
-        {
+        if is_expn_of(expr.span, "assert_eq").is_some() || is_expn_of(expr.span, "assert_ne").is_some() {
             self.panic_span = Some(expr.span);
         }
 

src/tools/clippy/clippy_lints/src/fallible_impl_from.rs

@@ -65,11 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
     }
 }
 
-fn lint_impl_body<'tcx>(
-    cx: &LateContext<'tcx>,
-    impl_span: Span,
-    impl_items: &[hir::ImplItemRef<'_>],
-) {
+fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[hir::ImplItemRef<'_>]) {
     use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
     use rustc_hir::{Expr, ExprKind, ImplItemKind, QPath};
 

src/tools/clippy/clippy_lints/src/functions/must_use.rs

@@ -27,10 +27,7 @@ pub(super) fn check_item(cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         if let Some(attr) = attr {
             check_needless_must_use(cx, sig.decl, item.hir_id(), item.span, fn_header_span, attr);
             return;
-        } else if is_public
-            && !is_proc_macro(cx.sess(), attrs)
-            && !attrs.iter().any(|a| a.has_name(sym::no_mangle))
-        {
+        } else if is_public && !is_proc_macro(cx.sess(), attrs) && !attrs.iter().any(|a| a.has_name(sym::no_mangle)) {
             check_must_use_candidate(
                 cx,
                 sig.decl,
@@ -52,10 +49,7 @@ pub(super) fn check_impl_item(cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<
         let attr = must_use_attr(attrs);
         if let Some(attr) = attr {
             check_needless_must_use(cx, sig.decl, item.hir_id(), item.span, fn_header_span, attr);
-        } else if is_public
-            && !is_proc_macro(cx.sess(), attrs)
-            && trait_ref_of_method(cx, item.hir_id()).is_none()
-        {
+        } else if is_public && !is_proc_macro(cx.sess(), attrs) && trait_ref_of_method(cx, item.hir_id()).is_none() {
             check_must_use_candidate(
                 cx,
                 sig.decl,
@@ -192,25 +186,20 @@ fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut DefIdSet)
 
 static KNOWN_WRAPPER_TYS: &[&[&str]] = &[&["alloc", "rc", "Rc"], &["std", "sync", "Arc"]];
 
-fn is_mutable_ty<'tcx>(
-    cx: &LateContext<'tcx>,
-    ty: Ty<'tcx>,
-    span: Span,
-    tys: &mut DefIdSet,
-) -> bool {
+fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &mut DefIdSet) -> bool {
     match *ty.kind() {
         // primitive types are never mutable
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
         ty::Adt(adt, substs) => {
             tys.insert(adt.did) && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
                 || KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did, path))
                     && substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
-        }
+        },
         ty::Tuple(substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)),
         ty::Array(ty, _) | ty::Slice(ty) => is_mutable_ty(cx, ty, span, tys),
         ty::RawPtr(ty::TypeAndMut { ty, mutbl }) | ty::Ref(_, ty, mutbl) => {
             mutbl == hir::Mutability::Mut || is_mutable_ty(cx, ty, span, tys)
-        }
+        },
         // calling something constitutes a side effect, so return true on all callables
         // also never calls need not be used, so return true for them, too
         _ => true,
@@ -249,13 +238,11 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
                     }
                     tys.clear();
                 }
-            }
-            Assign(target, ..)
-            | AssignOp(_, target, _)
-            | AddrOf(_, hir::Mutability::Mut, target) => {
+            },
+            Assign(target, ..) | AssignOp(_, target, _) | AddrOf(_, hir::Mutability::Mut, target) => {
                 self.mutates_static |= is_mutated_static(target)
-            }
-            _ => {}
+            },
+            _ => {},
         }
     }
 
@@ -276,7 +263,10 @@ fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
 }
 
 fn mutates_static<'tcx>(cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_>) -> bool {
-    let mut v = StaticMutVisitor { cx, mutates_static: false };
+    let mut v = StaticMutVisitor {
+        cx,
+        mutates_static: false,
+    };
     intravisit::walk_expr(&mut v, &body.value);
     v.mutates_static
 }

src/tools/clippy/clippy_lints/src/loops/mut_range_bound.rs

@@ -7,12 +7,15 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::{mir::FakeReadCause, ty};
 use rustc_span::source_map::Span;
-use rustc_typeck::expr_use_visitor::{
-    ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId,
-};
+use rustc_typeck::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 
 pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_>) {
-    if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(arg) {
+    if let Some(higher::Range {
+        start: Some(start),
+        end: Some(end),
+        ..
+    }) = higher::range(arg)
+    {
         let mut_ids = vec![check_for_mutability(cx, start), check_for_mutability(cx, end)];
         if mut_ids[0].is_some() || mut_ids[1].is_some() {
             let (span_low, span_high) = check_for_mutation(cx, body, &mut_ids);
@@ -105,13 +108,7 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate<'_, 'tcx> {
         }
     }
 
-    fn fake_read(
-        &mut self,
-        _: rustc_typeck::expr_use_visitor::Place<'tcx>,
-        _: FakeReadCause,
-        _: HirId,
-    ) {
-    }
+    fn fake_read(&mut self, _: rustc_typeck::expr_use_visitor::Place<'tcx>, _: FakeReadCause, _: HirId) {}
 }
 
 impl MutatePairDelegate<'_, '_> {