couple of clippy::complexity fixes

matthiaskrgr · matthiaskrgr · commit 7c2d57e0fa16 · 2022-04-13T22:51:34.000+02:00
diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
@@ -832,7 +832,7 @@ impl Diagnostic {
         name: impl Into<Cow<'static, str>>,
         arg: DiagnosticArgValue<'static>,
     ) -> &mut Self {
-        self.args.push((name.into(), arg.into()));
+        self.args.push((name.into(), arg));
         self
     }
 
diff --git a/compiler/rustc_expand/src/mbe/macro_check.rs b/compiler/rustc_expand/src/mbe/macro_check.rs
@@ -270,7 +270,7 @@ fn check_binders(
                     MISSING_FRAGMENT_SPECIFIER,
                     span,
                     node_id,
-                    &format!("missing fragment specifier"),
+                    "missing fragment specifier",
                 );
             }
             if !macros.is_empty() {
diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
@@ -63,9 +63,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     /// common state. Used in coherence.
     pub fn fork(&self) -> Self {
         Self {
-            tcx: self.tcx.clone(),
-            defining_use_anchor: self.defining_use_anchor.clone(),
-            in_progress_typeck_results: self.in_progress_typeck_results.clone(),
+            tcx: self.tcx,
+            defining_use_anchor: self.defining_use_anchor,
+            in_progress_typeck_results: self.in_progress_typeck_results,
             inner: self.inner.clone(),
             skip_leak_check: self.skip_leak_check.clone(),
             lexical_region_resolutions: self.lexical_region_resolutions.clone(),
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs
@@ -44,7 +44,7 @@ pub fn symbols(input: TokenStream) -> TokenStream {
 #[proc_macro]
 #[allow_internal_unstable(step_trait, rustc_attrs, trusted_step)]
 pub fn newtype_index(input: TokenStream) -> TokenStream {
-    newtype::newtype(input).into()
+    newtype::newtype(input)
 }
 
 decl_derive!([HashStable, attributes(stable_hasher)] => hash_stable::hash_stable_derive);
diff --git a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
@@ -191,7 +191,7 @@ impl<'tcx> Ty<'tcx> {
         tcx: TyCtxt<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
     ) -> DefIdForest<'tcx> {
-        tcx.type_uninhabited_from(param_env.and(self)).clone()
+        tcx.type_uninhabited_from(param_env.and(self))
     }
 }
 
diff --git a/compiler/rustc_mir_build/src/build/expr/as_constant.rs b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
@@ -39,7 +39,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         }
                     };
 
-                Constant { span, user_ty: None, literal: literal.into() }
+                Constant { span, user_ty: None, literal }
             }
             ExprKind::NonHirLiteral { lit, user_ty } => {
                 let user_ty = user_ty.map(|user_ty| {
diff --git a/compiler/rustc_mir_build/src/build/expr/into.rs b/compiler/rustc_mir_build/src/build/expr/into.rs
@@ -423,11 +423,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         }
                         thir::InlineAsmOperand::Const { value, span } => {
                             mir::InlineAsmOperand::Const {
-                                value: Box::new(Constant {
-                                    span,
-                                    user_ty: None,
-                                    literal: value.into(),
-                                }),
+                                value: Box::new(Constant { span, user_ty: None, literal: value }),
                             }
                         }
                         thir::InlineAsmOperand::SymFn { expr } => mir::InlineAsmOperand::SymFn {
diff --git a/compiler/rustc_mir_build/src/build/matches/test.rs b/compiler/rustc_mir_build/src/build/matches/test.rs
@@ -441,7 +441,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     // Need to experiment.
                     user_ty: None,
 
-                    literal: method.into(),
+                    literal: method,
                 })),
                 args: vec![val, expect],
                 destination: Some((eq_result, eq_block)),
diff --git a/compiler/rustc_mir_transform/src/check_unsafety.rs b/compiler/rustc_mir_transform/src/check_unsafety.rs
@@ -539,13 +539,13 @@ fn report_unused_unsafe(tcx: TyCtxt<'_>, kind: UnusedUnsafe, id: HirId) {
             UnusedUnsafe::InUnsafeBlock(id) => {
                 db.span_label(
                     tcx.sess.source_map().guess_head_span(tcx.hir().span(id)),
-                    format!("because it's nested under this `unsafe` block"),
+                    "because it's nested under this `unsafe` block",
                 );
             }
             UnusedUnsafe::InUnsafeFn(id, usage_lint_root) => {
                 db.span_label(
                     tcx.sess.source_map().guess_head_span(tcx.hir().span(id)),
-                    format!("because it's nested under this `unsafe` fn"),
+                    "because it's nested under this `unsafe` fn",
                 )
                 .note(
                     "this `unsafe` block does contain unsafe operations, \
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
@@ -234,13 +234,13 @@ impl<'a> StringReader<'a> {
             rustc_lexer::TokenKind::InvalidIdent
                 // Do not recover an identifier with emoji if the codepoint is a confusable
                 // with a recoverable substitution token, like `➖`.
-                if UNICODE_ARRAY
+                if !UNICODE_ARRAY
                     .iter()
-                    .find(|&&(c, _, _)| {
+                    .any(|&(c, _, _)| {
                         let sym = self.str_from(start);
                         sym.chars().count() == 1 && c == sym.chars().next().unwrap()
                     })
-                    .is_none() =>
+                     =>
             {
                 let sym = nfc_normalize(self.str_from(start));
                 let span = self.mk_sp(start, self.pos);
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
@@ -133,9 +133,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             }
 
             // `Deprecation` is just two pointers, no need to intern it
-            let depr_entry = DeprecationEntry::local(depr.clone(), def_id);
+            let depr_entry = DeprecationEntry::local(*depr, def_id);
             self.index.depr_map.insert(def_id, depr_entry);
-        } else if let Some(parent_depr) = self.parent_depr.clone() {
+        } else if let Some(parent_depr) = self.parent_depr {
             if inherit_deprecation.yes() {
                 is_deprecated = true;
                 info!("tagging child {:?} as deprecated from parent", def_id);
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
@@ -238,7 +238,7 @@ impl Session {
             }
             diag.emit();
             // If we should err, make sure we did.
-            if must_err && !self.has_errors().is_some() {
+            if must_err && self.has_errors().is_none() {
                 // We have skipped a feature gate, and not run into other errors... reject.
                 self.err(
                     "`-Zunleash-the-miri-inside-of-you` may not be used to circumvent feature \
diff --git a/compiler/rustc_target/src/abi/call/sparc64.rs b/compiler/rustc_target/src/abi/call/sparc64.rs
@@ -113,11 +113,11 @@ where
             data = arg_scalar(cx, &scalar, offset, data);
         }
         abi::Abi::Aggregate { .. } => {
-            for i in 0..layout.fields.count().clone() {
+            for i in 0..layout.fields.count() {
                 if offset < layout.fields.offset(i) {
                     offset = layout.fields.offset(i);
                 }
-                data = parse_structure(cx, layout.field(cx, i).clone(), data.clone(), offset);
+                data = parse_structure(cx, layout.field(cx, i), data.clone(), offset);
             }
         }
         _ => {
@@ -161,7 +161,7 @@ where
 
             let mut data = parse_structure(
                 cx,
-                arg.layout.clone(),
+                arg.layout,
                 Sdata {
                     prefix: [None; 8],
                     prefix_index: 0,
diff --git a/compiler/rustc_trait_selection/src/traits/on_unimplemented.rs b/compiler/rustc_trait_selection/src/traits/on_unimplemented.rs
@@ -258,7 +258,7 @@ impl<'tcx> OnUnimplementedDirective {
                 enclosing_scope = Some(enclosing_scope_.clone());
             }
 
-            append_const_msg = command.append_const_msg.clone();
+            append_const_msg = command.append_const_msg;
         }
 
         OnUnimplementedNote {
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
@@ -415,8 +415,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .get_if_local(def_id)
                     .and_then(|node| node.body_id())
                     .into_iter()
-                    .map(|id| tcx.hir().body(id).params)
-                    .flatten();
+                    .flat_map(|id| tcx.hir().body(id).params)
+                    ;
 
                 for param in params {
                     spans.push_span_label(param.span, String::new());
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs b/compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs
@@ -646,7 +646,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // now get all predicates in the same types as the where bounds, so we can chain them
         let predicates_from_where =
-            where_predicates.iter().flatten().map(|bounds| bounds.iter()).flatten();
+            where_predicates.iter().flatten().flat_map(|bounds| bounds.iter());
 
         // extract all bounds from the source code using their spans
         let all_matching_bounds_strs = expected_generic_param

Original file line number	Diff line number	Diff line change
`@@ -832,7 +832,7 @@ impl Diagnostic {`
`832`	`832`	`name: impl Into<Cow<'static, str>>,`
`833`	`833`	`arg: DiagnosticArgValue<'static>,`
`834`	`834`	`) -> &mut Self {`
`835`		`- self.args.push((name.into(), arg.into()));`
	`835`	`+ self.args.push((name.into(), arg));`
`836`	`836`	`self`
`837`	`837`	`}`
`838`	`838`
Original file line number	Diff line number	Diff line change
`@@ -270,7 +270,7 @@ fn check_binders(`
`270`	`270`	`MISSING_FRAGMENT_SPECIFIER,`
`271`	`271`	`span,`
`272`	`272`	`node_id,`
`273`		`- &format!("missing fragment specifier"),`
	`273`	`+ "missing fragment specifier",`
`274`	`274`	`);`
`275`	`275`	`}`
`276`	`276`	`if !macros.is_empty() {`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ pub fn symbols(input: TokenStream) -> TokenStream {`
`44`	`44`	`#[proc_macro]`
`45`	`45`	`#[allow_internal_unstable(step_trait, rustc_attrs, trusted_step)]`
`46`	`46`	`pub fn newtype_index(input: TokenStream) -> TokenStream {`
`47`		`- newtype::newtype(input).into()`
	`47`	`+ newtype::newtype(input)`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`decl_derive!([HashStable, attributes(stable_hasher)] => hash_stable::hash_stable_derive);`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ impl<'tcx> Ty<'tcx> {`
`191`	`191`	`tcx: TyCtxt<'tcx>,`
`192`	`192`	`param_env: ty::ParamEnv<'tcx>,`
`193`	`193`	`) -> DefIdForest<'tcx> {`
`194`		`- tcx.type_uninhabited_from(param_env.and(self)).clone()`
	`194`	`+ tcx.type_uninhabited_from(param_env.and(self))`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`39`	`39`	`}`
`40`	`40`	`};`
`41`	`41`
`42`		`- Constant { span, user_ty: None, literal: literal.into() }`
	`42`	`+ Constant { span, user_ty: None, literal }`
`43`	`43`	`}`
`44`	`44`	`ExprKind::NonHirLiteral { lit, user_ty } => {`
`45`	`45`	`let user_ty = user_ty.map(\|user_ty\| {`
Original file line number	Diff line number	Diff line change
`@@ -423,11 +423,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`423`	`423`	`}`
`424`	`424`	`thir::InlineAsmOperand::Const { value, span } => {`
`425`	`425`	`mir::InlineAsmOperand::Const {`
`426`		`- value: Box::new(Constant {`
`427`		`- span,`
`428`		`- user_ty: None,`
`429`		`- literal: value.into(),`
`430`		`- }),`
	`426`	`+ value: Box::new(Constant { span, user_ty: None, literal: value }),`
`431`	`427`	`}`
`432`	`428`	`}`
`433`	`429`	`thir::InlineAsmOperand::SymFn { expr } => mir::InlineAsmOperand::SymFn {`
Original file line number	Diff line number	Diff line change
`@@ -238,7 +238,7 @@ impl Session {`
`238`	`238`	`}`
`239`	`239`	`diag.emit();`
`240`	`240`	`// If we should err, make sure we did.`
`241`		`- if must_err && !self.has_errors().is_some() {`
	`241`	`+ if must_err && self.has_errors().is_none() {`
`242`	`242`	`// We have skipped a feature gate, and not run into other errors... reject.`
`243`	`243`	`self.err(`
`244`	`244`	"`-Zunleash-the-miri-inside-of-you` may not be used to circumvent feature \
Original file line number	Diff line number	Diff line change
`@@ -113,11 +113,11 @@ where`
`113`	`113`	`data = arg_scalar(cx, &scalar, offset, data);`
`114`	`114`	`}`
`115`	`115`	`abi::Abi::Aggregate { .. } => {`
`116`		`- for i in 0..layout.fields.count().clone() {`
	`116`	`+ for i in 0..layout.fields.count() {`
`117`	`117`	`if offset < layout.fields.offset(i) {`
`118`	`118`	`offset = layout.fields.offset(i);`
`119`	`119`	`}`
`120`		`- data = parse_structure(cx, layout.field(cx, i).clone(), data.clone(), offset);`
	`120`	`+ data = parse_structure(cx, layout.field(cx, i), data.clone(), offset);`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`	`_ => {`
`@@ -161,7 +161,7 @@ where`
`161`	`161`
`162`	`162`	`let mut data = parse_structure(`
`163`	`163`	`cx,`
`164`		`- arg.layout.clone(),`
	`164`	`+ arg.layout,`
`165`	`165`	`Sdata {`
`166`	`166`	`prefix: [None; 8],`
`167`	`167`	`prefix_index: 0,`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ impl<'tcx> OnUnimplementedDirective {`
`258`	`258`	`enclosing_scope = Some(enclosing_scope_.clone());`
`259`	`259`	`}`
`260`	`260`
`261`		`- append_const_msg = command.append_const_msg.clone();`
	`261`	`+ append_const_msg = command.append_const_msg;`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`OnUnimplementedNote {`