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;