Fix function and variable names

Author: xordi

clippy_lints/src/bool_assert_comparison.rs

@@ -40,23 +40,23 @@ fn is_bool_lit(e: &Expr<'_>) -> bool {
     ) && !e.span.from_expansion()
 }
 
-fn impl_not_trait_with_bool_out(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
+fn is_impl_not_trait_with_bool_out(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
     let ty = cx.typeck_results().expr_ty(e);
 
     cx.tcx
         .lang_items()
         .not_trait()
-        .filter(|id| implements_trait(cx, ty, *id, &[]))
-        .and_then(|id| {
-            cx.tcx.associated_items(id).find_by_name_and_kind(
+        .filter(|trait_id| implements_trait(cx, ty, *trait_id, &[]))
+        .and_then(|trait_id| {
+            cx.tcx.associated_items(trait_id).find_by_name_and_kind(
                 cx.tcx,
                 Ident::from_str("Output"),
                 ty::AssocKind::Type,
-                id,
+                trait_id,
             )
         })
-        .map_or(false, |item| {
-            let proj = cx.tcx.mk_projection(item.def_id, cx.tcx.mk_substs_trait(ty, &[]));
+        .map_or(false, |assoc_item| {
+            let proj = cx.tcx.mk_projection(assoc_item.def_id, cx.tcx.mk_substs_trait(ty, &[]));
             let nty = cx.tcx.normalize_erasing_regions(cx.param_env, proj);
 
             nty.is_bool()
@@ -82,7 +82,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison {
                             return;
                         }
 
-                        if !impl_not_trait_with_bool_out(cx, a) || !impl_not_trait_with_bool_out(cx, b) {
+                        if !is_impl_not_trait_with_bool_out(cx, a) || !is_impl_not_trait_with_bool_out(cx, b) {
                             // At this point the expression which is not a boolean
                             // literal does not implement Not trait with a bool output,
                             // so we cannot suggest to rewrite our code

tests/ui/bool_assert_comparison.rs

@@ -16,44 +16,44 @@ macro_rules! b {
 // Implements the Not trait but with an output type
 // that's not bool. Should not suggest a rewrite
 #[derive(Debug)]
-enum A {
+enum ImplNotTraitWithoutBool {
     VariantX(bool),
     VariantY(u32),
 }
 
-impl PartialEq<bool> for A {
+impl PartialEq<bool> for ImplNotTraitWithoutBool {
     fn eq(&self, other: &bool) -> bool {
         match *self {
-            A::VariantX(b) => b == *other,
+            ImplNotTraitWithoutBool::VariantX(b) => b == *other,
             _ => false,
         }
     }
 }
 
-impl Not for A {
+impl Not for ImplNotTraitWithoutBool {
     type Output = Self;
 
     fn not(self) -> Self::Output {
         match self {
-            A::VariantX(b) => A::VariantX(!b),
-            A::VariantY(0) => A::VariantY(1),
-            A::VariantY(_) => A::VariantY(0),
+            ImplNotTraitWithoutBool::VariantX(b) => ImplNotTraitWithoutBool::VariantX(!b),
+            ImplNotTraitWithoutBool::VariantY(0) => ImplNotTraitWithoutBool::VariantY(1),
+            ImplNotTraitWithoutBool::VariantY(_) => ImplNotTraitWithoutBool::VariantY(0),
         }
     }
 }
 
 // This type implements the Not trait with an Output of
 // type bool. Using assert!(..) must be suggested
 #[derive(Debug)]
-struct B;
+struct ImplNotTraitWithBool;
 
-impl PartialEq<bool> for B {
+impl PartialEq<bool> for ImplNotTraitWithBool {
     fn eq(&self, other: &bool) -> bool {
         false
     }
 }
 
-impl Not for B {
+impl Not for ImplNotTraitWithBool {
     type Output = bool;
 
     fn not(self) -> Self::Output {
@@ -62,8 +62,8 @@ impl Not for B {
 }
 
 fn main() {
-    let a = A::VariantX(true);
-    let b = B {};
+    let a = ImplNotTraitWithoutBool::VariantX(true);
+    let b = ImplNotTraitWithBool;
 
     assert_eq!("a".len(), 1);
     assert_eq!("a".is_empty(), false);