Add first attempts at checks for paths

Author: cgm616

clippy_lints/src/xor_used_as_pow.rs

@@ -1,8 +1,13 @@
-use crate::utils::{numeric_literal::NumericLiteral, snippet_opt, span_lint_and_help, span_lint_and_sugg};
+use crate::utils::{
+    last_path_segment, numeric_literal::NumericLiteral, qpath_res, snippet_opt, span_lint_and_help, span_lint_and_sugg,
+};
 use if_chain::if_chain;
 use rustc_ast::{LitIntType, LitKind};
 use rustc_errors::Applicability;
-use rustc_hir::{BinOpKind, Expr, ExprKind, ItemKind, Lit, Node};
+use rustc_hir::{
+    def::{DefKind, Res},
+    BinOpKind, BindingAnnotation, Expr, ExprKind, ItemKind, Lit, Node, PatKind, QPath,
+};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -42,7 +47,7 @@ impl LateLintPass<'_> for XorUsedAsPow {
         //  [ ] catch statements with literal or constant variables in rhs
         //  [x] check for overflows on suggested changes
         //  [x] ignore binary, octal, and hex literals in either side
-        //  [ ] avoid linting on enum discriminants
+        //  [x] avoid linting on enum discriminants
 
         let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
         if let Some(Node::Item(parent_item)) = cx.tcx.hir().find(parent_id) {
@@ -60,12 +65,42 @@ impl LateLintPass<'_> for XorUsedAsPow {
             then {
                 match &right.kind {
                     ExprKind::Lit(rhs) => {
-                        if let Some((rhs_val, rhs_type)) = unwrap_dec_int_literal(cx, rhs) {
-                            report_and_suggest(cx, lhs_val, rhs_val, expr.span);
+                        if let Some((rhs_val, _)) = unwrap_dec_int_literal(cx, rhs) {
+                            report_with_lit(cx, lhs_val, rhs_val, expr.span);
                         }
                     }
-                    ExprKind::Path(path) => {
-                        // TODO: fill this out
+                    ExprKind::Path(qpath) => {
+                        match qpath_res(cx, qpath, right.hir_id) {
+                            Res::Local(hir_id) => {
+                                if_chain! {
+                                    let node = cx.tcx.hir().get(hir_id);
+                                    if let Node::Binding(pat) = node;
+                                    if let PatKind::Binding(bind_ann, ..) = pat.kind;
+                                    if !matches!(bind_ann, BindingAnnotation::RefMut |
+                                            BindingAnnotation::Mutable);
+                                    let parent_node = cx.tcx.hir().get_parent_node(hir_id);
+                                    if let Some(Node::Local(parent_let_expr)) = cx.tcx.hir().find(parent_node);
+                                    if let Some(init) = parent_let_expr.init;
+                                    then {
+                                        match init.kind {
+                                            // immutable bindings that are initialized with literal
+                                            ExprKind::Lit(..) => report_with_ident(cx, lhs_val, qpath, expr.span),
+                                            // immutable bindings that are initialized with constant
+                                            ExprKind::Path(ref path) => {
+                                                let res = qpath_res(cx, path, init.hir_id);
+                                                if let Res::Def(DefKind::Const, ..) = res {
+                                                    report_with_ident(cx, lhs_val, qpath, expr.span);
+                                                }
+                                            }
+                                            _ => {},
+                                        }
+                                    }
+                                }
+                            },
+                            // constant
+                            Res::Def(DefKind::Const, ..) => report_with_ident(cx, lhs_val, qpath, expr.span),
+                            _ => {},
+                        }
                     }
                     _ => {}
                 }
@@ -89,49 +124,57 @@ fn unwrap_dec_int_literal(cx: &LateContext<'_>, lit: &Lit) -> Option<(u128, LitI
     }
 }
 
-fn report_and_suggest(cx: &LateContext<'_>, lhs: u128, rhs: u128, span: Span) {
+fn report_with_ident(cx: &LateContext<'_>, lhs: u128, rhs: &QPath<'_>, span: Span) {
+    match lhs {
+        2 => {
+            let ident = last_path_segment(rhs).ident.name.to_ident_string();
+            report_pow_of_two(cx, "1", &ident, span);
+        },
+        10 => report_pow_of_ten(cx, span),
+        _ => {},
+    }
+}
+
+fn report_with_lit(cx: &LateContext<'_>, lhs: u128, rhs: u128, span: Span) {
     if rhs > 127 {
         return;
     }
-
-    if lhs == 2 {
-        if rhs > 0 {
-            let int_type = if rhs <= 31 {
-                "u32"
+    match lhs {
+        2 => {
+            let lhs_str = if rhs <= 31 {
+                "1_u32"
             } else if rhs <= 63 {
-                "u64"
+                "1_u64"
             } else {
-                "u127"
+                "1_u127"
             };
 
-            span_lint_and_sugg(
-                cx,
-                XOR_USED_AS_POW,
-                span,
-                "it appears you are trying to get a power of two, but `^` is not an exponentiation operator",
-                "use a bitshift instead",
-                format!("1_{} << {}", int_type, rhs),
-                Applicability::MaybeIncorrect,
-            )
-        } else if rhs == 0 {
-            span_lint_and_sugg(
-                cx,
-                XOR_USED_AS_POW,
-                span,
-                "it appears you are trying to get a power of two, but `^` is not an exponentiation operator",
-                "try",
-                "1".to_owned(),
-                Applicability::MaybeIncorrect,
-            )
-        }
-    } else if lhs == 10 {
-        span_lint_and_help(
-            cx,
-            XOR_USED_AS_POW,
-            span,
-            "`^` is not an exponentiation operator but appears to have been used as one",
-            None,
-            "did you mean to use .pow()?",
-        )
+            report_pow_of_two(cx, lhs_str, &rhs.to_string(), span);
+        },
+        10 => report_pow_of_ten(cx, span),
+        _ => {},
     }
 }
+
+fn report_pow_of_two(cx: &LateContext<'_>, lhs: &str, rhs: &str, span: Span) {
+    span_lint_and_sugg(
+        cx,
+        XOR_USED_AS_POW,
+        span,
+        "it appears you are trying to get a power of two, but `^` is not an exponentiation operator",
+        "use a bitshift instead",
+        format!("{} << {}", lhs, rhs),
+        Applicability::MaybeIncorrect,
+    )
+}
+
+fn report_pow_of_ten(cx: &LateContext<'_>, span: Span) {
+    span_lint_and_help(
+        cx,
+        XOR_USED_AS_POW,
+        span,
+        "`^` is not an exponentiation operator but appears to have been used as one",
+        None,
+        "did you mean to use .pow()?",
+    )
+}