Used clippy to clean itself

JarredAllen · JarredAllen · commit 2e215b9f0d80 · 2020-06-27T17:29:22.000-07:00
diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs
@@ -442,15 +442,11 @@ fn is_relevant_trait(cx: &LateContext<'_, '_>, item: &TraitItem<'_>) -> bool {
 }
 
 fn is_relevant_block(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, block: &Block<'_>) -> bool {
-    if let Some(stmt) = block.stmts.first() {
-        match &stmt.kind {
+    block.stmts.first().map_or(block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, tables, e)), |stmt| match &stmt.kind {
             StmtKind::Local(_) => true,
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(cx, tables, expr),
             _ => false,
-        }
-    } else {
-        block.expr.as_ref().map_or(false, |e| is_relevant_expr(cx, tables, e))
-    }
+        })
 }
 
 fn is_relevant_expr(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, expr: &Expr<'_>) -> bool {
@@ -460,11 +456,7 @@ fn is_relevant_expr(cx: &LateContext<'_, '_>, tables: &ty::TypeckTables<'_>, exp
         ExprKind::Ret(None) | ExprKind::Break(_, None) => false,
         ExprKind::Call(path_expr, _) => {
             if let ExprKind::Path(qpath) = &path_expr.kind {
-                if let Some(fun_id) = tables.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
-                    !match_def_path(cx, fun_id, &paths::BEGIN_PANIC)
-                } else {
-                    true
-                }
+                tables.qpath_res(qpath, path_expr.hir_id).opt_def_id().map_or(true, |fun_id| !match_def_path(cx, fun_id, &paths::BEGIN_PANIC))
             } else {
                 true
             }
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
@@ -137,11 +137,7 @@ impl<'tcx, 'l> Visitor<'tcx> for ArmVisitor<'tcx, 'l> {
 
 impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {
     fn same_mutex(&self, cx: &LateContext<'_, '_>, op_mutex: &Expr<'_>) -> bool {
-        if let Some(arm_mutex) = self.found_mutex {
-            SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex)
-        } else {
-            false
-        }
+        self.found_mutex.map_or(false, |arm_mutex| SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex))
     }
 }
 
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
@@ -303,14 +303,10 @@ fn has_is_empty(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
     let ty = &walk_ptrs_ty(cx.tables.expr_ty(expr));
     match ty.kind {
         ty::Dynamic(ref tt, ..) => {
-            if let Some(principal) = tt.principal() {
-                cx.tcx
+            tt.principal().map_or(false, |principal| cx.tcx
                     .associated_items(principal.def_id())
                     .in_definition_order()
-                    .any(|item| is_is_empty(cx, &item))
-            } else {
-                false
-            }
+                    .any(|item| is_is_empty(cx, &item)))
         },
         ty::Projection(ref proj) => has_is_empty_impl(cx, proj.item_def_id),
         ty::Adt(id, _) => has_is_empty_impl(cx, id.did),
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
@@ -264,10 +264,11 @@ impl LiteralDigitGrouping {
 
         let (part, mistyped_suffixes, missing_char) = if let Some((_, exponent)) = &mut num_lit.exponent {
             (exponent, &["32", "64"][..], 'f')
-        } else if let Some(fraction) = &mut num_lit.fraction {
-            (fraction, &["32", "64"][..], 'f')
         } else {
-            (&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i')
+            num_lit.fraction.as_mut().map_or(
+                (&mut num_lit.integer, &["8", "16", "32", "64"][..], 'i'),
+                |fraction| (fraction, &["32", "64"][..], 'f')
+            )
         };
 
         let mut split = part.rsplit('_');
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
@@ -687,11 +687,7 @@ fn never_loop_expr(expr: &Expr<'_>, main_loop_id: HirId) -> NeverLoopResult {
             }
         },
         ExprKind::Break(_, ref e) | ExprKind::Ret(ref e) => {
-            if let Some(ref e) = *e {
-                combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak)
-            } else {
-                NeverLoopResult::AlwaysBreak
-            }
+            e.as_ref().map_or(NeverLoopResult::AlwaysBreak, |e| combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak))
         },
         ExprKind::InlineAsm(ref asm) => asm
             .operands
@@ -1882,11 +1878,7 @@ fn is_iterable_array<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'_, 'tcx>) -> bool {
     // IntoIterator is currently only implemented for array sizes <= 32 in rustc
     match ty.kind {
         ty::Array(_, n) => {
-            if let Some(val) = n.try_eval_usize(cx.tcx, cx.param_env) {
-                (0..=32).contains(&val)
-            } else {
-                false
-            }
+            n.try_eval_usize(cx.tcx, cx.param_env).map_or(false, |val| (0..=32).contains(&val))
         },
         _ => false,
     }
@@ -1899,11 +1891,7 @@ fn extract_expr_from_first_stmt<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<
         return None;
     }
     if let StmtKind::Local(ref local) = block.stmts[0].kind {
-        if let Some(expr) = local.init {
-            Some(expr)
-        } else {
-            None
-        }
+        local.init.map(|expr| expr)
     } else {
         None
     }
@@ -2023,15 +2011,11 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                 if let PatKind::Binding(.., ident, _) = local.pat.kind {
                     self.name = Some(ident.name);
 
-                    self.state = if let Some(ref init) = local.init {
-                        if is_integer_const(&self.cx, init, 0) {
+                    self.state = local.init.as_ref().map_or(VarState::Declared, |init| if is_integer_const(&self.cx, init, 0) {
                             VarState::Warn
                         } else {
                             VarState::Declared
-                        }
-                    } else {
-                        VarState::Declared
-                    }
+                        })
                 }
             }
         }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
@@ -2467,11 +2467,7 @@ fn derefs_to_slice<'a, 'tcx>(
             ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
             ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym!(vec_type)),
             ty::Array(_, size) => {
-                if let Some(size) = size.try_eval_usize(cx.tcx, cx.param_env) {
-                    size < 32
-                } else {
-                    false
-                }
+                size.try_eval_usize(cx.tcx, cx.param_env).map_or(false, |size| size < 32)
             },
             ty::Ref(_, inner, _) => may_slice(cx, inner),
             _ => false,
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -82,11 +82,7 @@ fn check_expression<'a, 'tcx>(
             (true, true)
         },
         hir::ExprKind::Block(ref block, _) => {
-            if let Some(expr) = &block.expr {
-                check_expression(cx, arg_id, &expr)
-            } else {
-                (false, false)
-            }
+            block.expr.as_ref().map_or((false, false), |expr| check_expression(cx, arg_id, &expr))
         },
         hir::ExprKind::Match(_, arms, _) => {
             let mut found_mapping = false;
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
@@ -87,16 +87,17 @@ fn fetch_const<'a>(
     if args.len() != 2 {
         return None;
     }
-    if let Some(c) = constant_simple(cx, cx.tables, &args[0]) {
-        if constant_simple(cx, cx.tables, &args[1]).is_none() {
-            // otherwise ignore
-            Some((m, c, &args[1]))
-        } else {
-            None
+    constant_simple(cx, cx.tables, &args[0]).map_or_else(
+        || {
+            constant_simple(cx, cx.tables, &args[1]).map(|c| (c, &args[0]))
+        },
+        |c| {
+            if constant_simple(cx, cx.tables, &args[1]).is_none() {
+                // otherwise ignore
+                Some((c, &args[1]))
+            } else {
+                None
+            }
         }
-    } else if let Some(c) = constant_simple(cx, cx.tables, &args[1]) {
-        Some((m, c, &args[0]))
-    } else {
-        None
-    }
+    ).map(|(c, arg)| (m, c, arg))
 }
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
@@ -682,16 +682,12 @@ fn check_to_owned(cx: &LateContext<'_, '_>, expr: &Expr<'_>, other: &Expr<'_>, l
 /// `unused_variables`'s idea
 /// of what it means for an expression to be "used".
 fn is_used(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
-    if let Some(parent) = get_parent_expr(cx, expr) {
-        match parent.kind {
+    get_parent_expr(cx, expr).map_or(true, |parent| match parent.kind {
             ExprKind::Assign(_, ref rhs, _) | ExprKind::AssignOp(_, _, ref rhs) => {
                 SpanlessEq::new(cx).eq_expr(rhs, expr)
             },
             _ => is_used(cx, parent),
-        }
-    } else {
-        true
-    }
+        })
 }
 
 /// Tests whether an expression is in a macro expansion (e.g., something
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
@@ -37,6 +37,7 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// # let optional: Option<u32> = Some(0);
+    /// # fn do_complicated_function() -> u32 { 5 };
     /// let _ = if let Some(foo) = optional {
     ///     foo
     /// } else {
@@ -54,9 +55,10 @@ declare_clippy_lint! {
     ///
     /// ```rust
     /// # let optional: Option<u32> = Some(0);
+    /// # fn do_complicated_function() -> u32 { 5 };
     /// let _ = optional.map_or(5, |foo| foo);
     /// let _ = optional.map_or_else(||{
-    ///     let y = do_complicated_function;
+    ///     let y = do_complicated_function();
     ///     y*y
     /// }, |foo| foo);
     /// ```
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
@@ -259,15 +259,10 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
 
 fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
     let (ret_span, appl) = if let Ok(fn_source) = cx.sess().source_map().span_to_snippet(span.with_hi(ty.span.hi())) {
-        if let Some(rpos) = fn_source.rfind("->") {
-            #[allow(clippy::cast_possible_truncation)]
-            (
+        fn_source.rfind("->").map_or((ty.span, Applicability::MaybeIncorrect), |rpos| (
                 ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
                 Applicability::MachineApplicable,
-            )
-        } else {
-            (ty.span, Applicability::MaybeIncorrect)
-        }
+            ))
     } else {
         (ty.span, Applicability::MaybeIncorrect)
     };
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
@@ -165,14 +165,10 @@ fn check_local<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, local: &'tcx Local<'_>, bin
 
 fn is_binding(cx: &LateContext<'_, '_>, pat_id: HirId) -> bool {
     let var_ty = cx.tables.node_type_opt(pat_id);
-    if let Some(var_ty) = var_ty {
-        match var_ty.kind {
+    var_ty.map_or(false, |var_ty| match var_ty.kind {
             ty::Adt(..) => false,
             _ => true,
-        }
-    } else {
-        false
-    }
+        })
 }
 
 fn check_pat<'a, 'tcx>(
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
@@ -1213,16 +1213,14 @@ fn span_lossless_lint(cx: &LateContext<'_, '_>, expr: &Expr<'_>, op: &Expr<'_>,
     // has parens on the outside, they are no longer needed.
     let mut applicability = Applicability::MachineApplicable;
     let opt = snippet_opt(cx, op.span);
-    let sugg = if let Some(ref snip) = opt {
-        if should_strip_parens(op, snip) {
+    let sugg = opt.as_ref().map_or_else(|| {
+        applicability = Applicability::HasPlaceholders;
+        ".."
+    }, |snip| if should_strip_parens(op, snip) {
             &snip[1..snip.len() - 1]
         } else {
             snip.as_str()
-        }
-    } else {
-        applicability = Applicability::HasPlaceholders;
-        ".."
-    };
+        });
 
     span_lint_and_sugg(
         cx,
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
@@ -167,14 +167,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UseSelf {
             if let TyKind::Path(QPath::Resolved(_, ref item_path)) = item_type.kind;
             then {
                 let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
-                let should_check = if let Some(ref params) = *parameters {
-                    !params.parenthesized && !params.args.iter().any(|arg| match arg {
+                let should_check = parameters.as_ref().map_or(true, |params| !params.parenthesized && !params.args.iter().any(|arg| match arg {
                         GenericArg::Lifetime(_) => true,
                         _ => false,
-                    })
-                } else {
-                    true
-                };
+                    }));
 
                 if should_check {
                     let visitor = &mut UseSelfVisitor {
diff --git a/clippy_lints/src/utils/attrs.rs b/clippy_lints/src/utils/attrs.rs
@@ -65,17 +65,18 @@ pub fn get_attr<'a>(
         };
         let attr_segments = &attr.path.segments;
         if attr_segments.len() == 2 && attr_segments[0].ident.to_string() == "clippy" {
-            if let Some(deprecation_status) =
-                BUILTIN_ATTRIBUTES
+            BUILTIN_ATTRIBUTES
                     .iter()
                     .find_map(|(builtin_name, deprecation_status)| {
                         if *builtin_name == attr_segments[1].ident.to_string() {
                             Some(deprecation_status)
                         } else {
                             None
                         }
-                    })
-            {
+                    }).map_or_else(|| {
+                sess.span_err(attr_segments[1].ident.span, "Usage of unknown attribute");
+                false
+            }, |deprecation_status| {
                 let mut diag = sess.struct_span_err(attr_segments[1].ident.span, "Usage of deprecated attribute");
                 match *deprecation_status {
                     DeprecationStatus::Deprecated => {
@@ -97,10 +98,7 @@ pub fn get_attr<'a>(
                         attr_segments[1].ident.to_string() == name
                     },
                 }
-            } else {
-                sess.span_err(attr_segments[1].ident.span, "Usage of unknown attribute");
-                false
-            }
+            })
         } else {
             false
         }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
diff --git a/clippy_lints/src/utils/numeric_literal.rs b/clippy_lints/src/utils/numeric_literal.rs
diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs

Original file line number	Diff line number	Diff line change
`@@ -137,11 +137,7 @@ impl<'tcx, 'l> Visitor<'tcx> for ArmVisitor<'tcx, 'l> {`
`137`	`137`
`138`	`138`	`impl<'tcx, 'l> ArmVisitor<'tcx, 'l> {`
`139`	`139`	`fn same_mutex(&self, cx: &LateContext<'_, '_>, op_mutex: &Expr<'_>) -> bool {`
`140`		`- if let Some(arm_mutex) = self.found_mutex {`
`141`		`- SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex)`
`142`		`- } else {`
`143`		`- false`
`144`		`- }`
	`140`	`+ self.found_mutex.map_or(false, \|arm_mutex\| SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex))`
`145`	`141`	`}`
`146`	`142`	`}`
`147`	`143`