fixed style issues and incorrect implementation

Author: michirakara

compiler/rustc_expand/src/mbe/macro_parser.rs

@@ -678,13 +678,14 @@ impl TtParser {
                         // edition-specific matching behavior for non-terminals.
                         let nt = match parser.to_mut().parse_nonterminal(kind) {
                             Err(err) => {
-                                let guarantee = err.with_span_label(
-                                    span,
-                                    format!(
+                                let guarantee = err
+                                    .with_span_label(
+                                        span,
+                                        format!(
                                         "while parsing argument for this `{kind}` macro fragment"
                                     ),
-                                )
-                                .emit();
+                                    )
+                                    .emit();
                                 return ErrorReported(guarantee);
                             }
                             Ok(nt) => nt,

compiler/rustc_index_macros/src/newtype.rs

@@ -122,7 +122,7 @@ impl Parse for Newtype {
                 #gate_rustc_only
                 impl ::std::iter::Step for #name {
                     #[inline]
-                    fn steps_between(start: &Self, end: &Self) -> (usize,Option<usize>) {
+                    fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>) {
                         <usize as ::std::iter::Step>::steps_between(
                             &Self::index(*start),
                             &Self::index(*end),

compiler/rustc_middle/src/ty/normalize_erasing_regions.rs

@@ -166,10 +166,12 @@ impl<'tcx> NormalizeAfterErasingRegionsFolder<'tcx> {
     ) -> ty::GenericArg<'tcx> {
         let arg = self.param_env.and(arg);
 
-        self.tcx.try_normalize_generic_arg_after_erasing_regions(arg).unwrap_or_else(|_| bug!(
+        self.tcx.try_normalize_generic_arg_after_erasing_regions(arg).unwrap_or_else(|_| {
+            bug!(
             "Failed to normalize {:?}, maybe try to call `try_normalize_erasing_regions` instead",
             arg.value
-        ))
+        )
+        })
     }
 }
 

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -117,7 +117,8 @@ impl<'tcx> UnsafetyVisitor<'_, 'tcx> {
                 let suggestion = suggestion
                     .and_then(|suggestion| {
                         sm.indentation_before(span).map(|indent| {
-                            format!("{}// TODO: Audit that {}.\n", indent, suggestion) // ignore-tidy-todo
+                            format!("{}// TODO: Audit that {}.\n", indent, suggestion)
+                            // ignore-tidy-todo
                         })
                     })
                     .unwrap_or_default();

compiler/rustc_parse/src/lexer/mod.rs

@@ -519,7 +519,8 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
                         .with_code(E0766)
                         .emit()
                 }
-                self.cook_unicode(token::ByteStr, Mode::ByteStr, start, end, 2, 1) // b" "
+                self.cook_unicode(token::ByteStr, Mode::ByteStr, start, end, 2, 1)
+                // b" "
             }
             rustc_lexer::LiteralKind::CStr { terminated } => {
                 if !terminated {
@@ -537,7 +538,8 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
                 if let Some(n_hashes) = n_hashes {
                     let n = u32::from(n_hashes);
                     let kind = token::StrRaw(n_hashes);
-                    self.cook_unicode(kind, Mode::RawStr, start, end, 2 + n, 1 + n) // r##" "##
+                    self.cook_unicode(kind, Mode::RawStr, start, end, 2 + n, 1 + n)
+                // r##" "##
                 } else {
                     self.report_raw_str_error(start, 1);
                 }
@@ -546,7 +548,8 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
                 if let Some(n_hashes) = n_hashes {
                     let n = u32::from(n_hashes);
                     let kind = token::ByteStrRaw(n_hashes);
-                    self.cook_unicode(kind, Mode::RawByteStr, start, end, 3 + n, 1 + n) // br##" "##
+                    self.cook_unicode(kind, Mode::RawByteStr, start, end, 3 + n, 1 + n)
+                // br##" "##
                 } else {
                     self.report_raw_str_error(start, 2);
                 }
@@ -555,7 +558,8 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
                 if let Some(n_hashes) = n_hashes {
                     let n = u32::from(n_hashes);
                     let kind = token::CStrRaw(n_hashes);
-                    self.cook_unicode(kind, Mode::RawCStr, start, end, 3 + n, 1 + n) // cr##" "##
+                    self.cook_unicode(kind, Mode::RawCStr, start, end, 3 + n, 1 + n)
+                // cr##" "##
                 } else {
                     self.report_raw_str_error(start, 2);
                 }

compiler/rustc_resolve/src/diagnostics.rs

@@ -1742,7 +1742,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         )) = binding.kind
         {
             let def_id = self.tcx.parent(ctor_def_id);
-            return self.field_idents(def_id)?.iter().map(|&f| f.span).reduce(Span::to); // None for `struct Foo()`
+            return self.field_idents(def_id)?.iter().map(|&f| f.span).reduce(Span::to);
+            // None for `struct Foo()`
         }
         None
     }

library/core/src/iter/range.rs

@@ -259,12 +259,13 @@ macro_rules! step_integer_impls {
                 step_unsigned_methods!();
 
                 #[inline]
-                fn steps_between(start: &Self, end: &Self) -> (usize,Option<usize>) {
+                fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>) {
                     if *start <= *end {
                         // This relies on $u_narrower <= usize
-                        ((*end-*start) as usize, Some((*end - *start) as usize))
+                        let steps = (*end - *start) as usize
+                        (steps, Some(steps))
                     } else {
-                        (0,None)
+                        (0, None)
                     }
                 }
 
@@ -299,7 +300,8 @@ macro_rules! step_integer_impls {
                         // Casting to isize extends the width but preserves the sign.
                         // Use wrapping_sub in isize space and cast to usize to compute
                         // the difference that might not fit inside the range of isize.
-                        ((*end as isize).wrapping_sub(*start as isize) as usize,Some((*end as isize).wrapping_sub(*start as isize) as usize))
+                        let steps = (*end as isize).wrapping_sub(*start as isize) as usize;
+                        (steps, Some(steps))
                     } else {
                         (0,None)
                     }
@@ -707,7 +709,7 @@ impl<A: Step> RangeIteratorImpl for ops::Range<A> {
     #[inline]
     default fn spec_advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
         let steps = Step::steps_between(&self.start, &self.end);
-        let available = if let Some(steps) = steps.1 { steps } else { steps.0 };
+        let available = steps.1.unwrap_or(steps.0);
 
         let taken = available.min(n);
 
@@ -745,7 +747,7 @@ impl<A: Step> RangeIteratorImpl for ops::Range<A> {
     #[inline]
     default fn spec_advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
         let steps = Step::steps_between(&self.start, &self.end);
-        let available = if let Some(steps) = steps.1 { steps } else { steps.0 };
+        let available = steps.1.unwrap_or(steps.0);
 
         let taken = available.min(n);
 
@@ -786,7 +788,7 @@ impl<T: TrustedStep> RangeIteratorImpl for ops::Range<T> {
     #[inline]
     fn spec_advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
         let steps = Step::steps_between(&self.start, &self.end);
-        let available = if let Some(steps) = steps.1 { steps } else { steps.0 };
+        let available = steps.1.unwrap_or(step.0);
 
         let taken = available.min(n);
 
@@ -827,7 +829,7 @@ impl<T: TrustedStep> RangeIteratorImpl for ops::Range<T> {
     #[inline]
     fn spec_advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
         let steps = Step::steps_between(&self.start, &self.end);
-        let available = if let Some(steps) = steps.1 { steps } else { steps.0 };
+        let available = steps.1.unwrap_or(steps.0);
 
         let taken = available.min(n);
 
@@ -849,11 +851,7 @@ impl<A: Step> Iterator for ops::Range<A> {
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        if self.start < self.end {
-            (0, Some(0))
-        } else {
-            Step::steps_between(&self.start, &self.end)
-        }
+        Step::steps_between(&self.start, &self.end)
     }
 
     #[inline]

src/tools/clippy/clippy_config/src/conf.rs

@@ -1,6 +1,6 @@
-use crate::ClippyConfiguration;
 use crate::msrvs::Msrv;
 use crate::types::{DisallowedPath, MacroMatcher, MatchLintBehaviour, PubUnderscoreFieldsBehaviour, Rename};
+use crate::ClippyConfiguration;
 use rustc_errors::Applicability;
 use rustc_session::Session;
 use rustc_span::edit_distance::edit_distance;

src/tools/clippy/clippy_config/src/lib.rs

@@ -26,5 +26,5 @@ mod metadata;
 pub mod msrvs;
 pub mod types;
 
-pub use conf::{Conf, get_configuration_metadata, lookup_conf_file, sanitize_explanation};
+pub use conf::{get_configuration_metadata, lookup_conf_file, sanitize_explanation, Conf};
 pub use metadata::ClippyConfiguration;

src/tools/clippy/clippy_config/src/msrvs.rs

@@ -1,7 +1,7 @@
 use rustc_ast::Attribute;
 use rustc_attr::parse_version;
 use rustc_session::{RustcVersion, Session};
-use rustc_span::{Symbol, sym};
+use rustc_span::{sym, Symbol};
 use serde::Deserialize;
 use std::fmt;
 

src/tools/clippy/clippy_config/src/types.rs

@@ -1,5 +1,5 @@
 use serde::de::{self, Deserializer, Visitor};
-use serde::{Deserialize, Serialize, ser};
+use serde::{ser, Deserialize, Serialize};
 use std::fmt;
 
 #[derive(Debug, Deserialize)]

src/tools/clippy/clippy_dev/src/fmt.rs

@@ -1,6 +1,6 @@
 use crate::clippy_project_root;
 use itertools::Itertools;
-use rustc_lexer::{TokenKind, tokenize};
+use rustc_lexer::{tokenize, TokenKind};
 use shell_escape::escape;
 use std::ffi::{OsStr, OsString};
 use std::ops::ControlFlow;

src/tools/clippy/clippy_dev/src/new_lint.rs

@@ -441,7 +441,7 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
 
 #[allow(clippy::too_many_lines)]
 fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str> {
-    use super::update_lints::{LintDeclSearchResult, match_tokens};
+    use super::update_lints::{match_tokens, LintDeclSearchResult};
     use rustc_lexer::TokenKind;
 
     let lint_name_upper = lint.name.to_uppercase();

src/tools/clippy/clippy_dev/src/update_lints.rs

@@ -1,7 +1,7 @@
 use crate::clippy_project_root;
 use aho_corasick::AhoCorasickBuilder;
 use itertools::Itertools;
-use rustc_lexer::{LiteralKind, TokenKind, tokenize, unescape};
+use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fmt::{self, Write};
@@ -1048,17 +1048,23 @@ mod tests {
             Lint::new("incorrect_match", "group1", "\"abc\"", "module_name", Range::default()),
         ];
         let mut expected: HashMap<String, Vec<Lint>> = HashMap::new();
-        expected.insert("group1".to_string(), vec![
-            Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name", Range::default()),
-            Lint::new("incorrect_match", "group1", "\"abc\"", "module_name", Range::default()),
-        ]);
-        expected.insert("group2".to_string(), vec![Lint::new(
-            "should_assert_eq2",
-            "group2",
-            "\"abc\"",
-            "module_name",
-            Range::default(),
-        )]);
+        expected.insert(
+            "group1".to_string(),
+            vec![
+                Lint::new("should_assert_eq", "group1", "\"abc\"", "module_name", Range::default()),
+                Lint::new("incorrect_match", "group1", "\"abc\"", "module_name", Range::default()),
+            ],
+        );
+        expected.insert(
+            "group2".to_string(),
+            vec![Lint::new(
+                "should_assert_eq2",
+                "group2",
+                "\"abc\"",
+                "module_name",
+                Range::default(),
+            )],
+        );
         assert_eq!(expected, Lint::by_lint_group(lints.into_iter()));
     }
 }

src/tools/clippy/clippy_lints/src/absolute_paths.rs

@@ -3,12 +3,12 @@ use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_from_proc_macro;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::{CRATE_DEF_INDEX, DefId};
+use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
 use rustc_hir::{HirId, ItemKind, Node, Path};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
-use rustc_span::Symbol;
 use rustc_span::symbol::kw;
+use rustc_span::Symbol;
 
 declare_clippy_lint! {
     /// ### What it does

src/tools/clippy/clippy_lints/src/almost_complete_range.rs

@@ -1,5 +1,5 @@
-use clippy_config::Conf;
 use clippy_config::msrvs::{self, Msrv};
+use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{trim_span, walk_span_to_context};
 use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};

src/tools/clippy/clippy_lints/src/approx_const.rs

@@ -1,10 +1,10 @@
-use clippy_config::Conf;
 use clippy_config::msrvs::{self, Msrv};
+use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{RustcVersion, impl_lint_pass};
+use rustc_session::{impl_lint_pass, RustcVersion};
 use rustc_span::symbol;
 use std::f64::consts as f64;
 

src/tools/clippy/clippy_lints/src/arc_with_non_send_sync.rs

@@ -4,8 +4,8 @@ use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty;
-use rustc_middle::ty::GenericArgKind;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
+use rustc_middle::ty::GenericArgKind;
 use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 

src/tools/clippy/clippy_lints/src/assertions_on_constants.rs

@@ -1,7 +1,7 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_inside_always_const_context;
-use clippy_utils::macros::{PanicExpn, find_assert_args, root_macro_call_first_node};
+use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;

src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::macros::{PanicExpn, find_assert_args, root_macro_call_first_node};
+use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{has_debug_impl, is_copy, is_type_diagnostic_item};
 use clippy_utils::usage::local_used_after_expr;

src/tools/clippy/clippy_lints/src/assigning_clones.rs

@@ -1,7 +1,7 @@
-use clippy_config::Conf;
 use clippy_config::msrvs::{self, Msrv};
+use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::mir::{PossibleBorrowerMap, enclosing_mir};
+use clippy_utils::mir::{enclosing_mir, PossibleBorrowerMap};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{is_diag_trait_item, is_in_test, last_path_segment, local_is_initialized, path_to_local};
 use rustc_errors::Applicability;

src/tools/clippy/clippy_lints/src/attrs/allow_attributes_without_reason.rs

@@ -1,4 +1,4 @@
-use super::{ALLOW_ATTRIBUTES_WITHOUT_REASON, Attribute};
+use super::{Attribute, ALLOW_ATTRIBUTES_WITHOUT_REASON};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
 use rustc_ast::{MetaItemInner, MetaItemKind};

src/tools/clippy/clippy_lints/src/attrs/blanket_clippy_restriction_lints.rs

@@ -1,10 +1,10 @@
-use super::BLANKET_CLIPPY_RESTRICTION_LINTS;
 use super::utils::extract_clippy_lint;
+use super::BLANKET_CLIPPY_RESTRICTION_LINTS;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
 use rustc_ast::MetaItemInner;
 use rustc_lint::{EarlyContext, Level, LintContext};
 use rustc_span::symbol::Symbol;
-use rustc_span::{DUMMY_SP, sym};
+use rustc_span::{sym, DUMMY_SP};
 
 pub(super) fn check(cx: &EarlyContext<'_>, name: Symbol, items: &[MetaItemInner]) {
     for lint in items {

src/tools/clippy/clippy_lints/src/attrs/deprecated_cfg_attr.rs

@@ -1,4 +1,4 @@
-use super::{Attribute, DEPRECATED_CFG_ATTR, DEPRECATED_CLIPPY_CFG_ATTR, unnecessary_clippy_cfg};
+use super::{unnecessary_clippy_cfg, Attribute, DEPRECATED_CFG_ATTR, DEPRECATED_CLIPPY_CFG_ATTR};
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast::AttrStyle;

src/tools/clippy/clippy_lints/src/attrs/duplicated_attributes.rs

@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::{Attribute, MetaItem};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_lint::EarlyContext;
-use rustc_span::{Span, sym};
+use rustc_span::{sym, Span};
 use std::collections::hash_map::Entry;
 
 fn emit_if_duplicated(

src/tools/clippy/clippy_lints/src/attrs/inline_always.rs

@@ -1,10 +1,10 @@
-use super::INLINE_ALWAYS;
 use super::utils::is_word;
+use super::INLINE_ALWAYS;
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::Attribute;
 use rustc_lint::LateContext;
 use rustc_span::symbol::Symbol;
-use rustc_span::{Span, sym};
+use rustc_span::{sym, Span};
 
 pub(super) fn check(cx: &LateContext<'_>, span: Span, name: Symbol, attrs: &[Attribute]) {
     if span.from_expansion() {