Add lint for use of ^ operator as exponentiation.

Author: LunaBorowska

CHANGELOG.md

@@ -2047,6 +2047,7 @@ Released 2018-09-13
 [`wrong_pub_self_convention`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_pub_self_convention
 [`wrong_self_convention`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention
 [`wrong_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_transmute
+[`xor_used_as_pow`]: https://rust-lang.github.io/rust-clippy/master/index.html#xor_used_as_pow
 [`zero_divided_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_divided_by_zero
 [`zero_prefixed_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_prefixed_literal
 [`zero_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_ptr

clippy_lints/src/lib.rs

@@ -335,6 +335,7 @@ mod verbose_file_reads;
 mod wildcard_dependencies;
 mod wildcard_imports;
 mod write;
+mod xor_used_as_pow;
 mod zero_div_zero;
 // end lints modules, do not remove this comment, it’s used in `update_lints`
 
@@ -909,6 +910,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &write::WRITELN_EMPTY_STRING,
         &write::WRITE_LITERAL,
         &write::WRITE_WITH_NEWLINE,
+        &xor_used_as_pow::XOR_USED_AS_POW,
         &zero_div_zero::ZERO_DIVIDED_BY_ZERO,
     ]);
     // end register lints, do not remove this comment, it’s used in `update_lints`
@@ -1148,6 +1150,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_early_pass(|| box asm_syntax::InlineAsmX86AttSyntax);
     store.register_early_pass(|| box asm_syntax::InlineAsmX86IntelSyntax);
     store.register_late_pass(|| box undropped_manually_drops::UndroppedManuallyDrops);
+    store.register_early_pass(|| box xor_used_as_pow::XorUsedAsPow);
 
 
     store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
@@ -1557,6 +1560,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&write::WRITELN_EMPTY_STRING),
         LintId::of(&write::WRITE_LITERAL),
         LintId::of(&write::WRITE_WITH_NEWLINE),
+        LintId::of(&xor_used_as_pow::XOR_USED_AS_POW),
         LintId::of(&zero_div_zero::ZERO_DIVIDED_BY_ZERO),
     ]);
 
@@ -1820,6 +1824,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&unused_io_amount::UNUSED_IO_AMOUNT),
         LintId::of(&unwrap::PANICKING_UNWRAP),
         LintId::of(&vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+        LintId::of(&xor_used_as_pow::XOR_USED_AS_POW),
     ]);
 
     store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![

clippy_lints/src/xor_used_as_pow.rs

@@ -0,0 +1,77 @@
+use crate::utils::{span_help_and_lint, span_lint_and_sugg};
+use if_chain::if_chain;
+use rustc::lint::{in_external_macro, EarlyContext, EarlyLintPass, LintArray, LintPass};
+use rustc::{declare_lint_pass, declare_tool_lint};
+use rustc_errors::Applicability;
+use syntax::ast::{BinOpKind, Expr, ExprKind, LitKind};
+
+declare_clippy_lint! {
+    /// **What it does:** Checks for use of `^` operator when exponentiation was intended.
+    ///
+    /// **Why is this bad?** This is most probably a typo.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust,ignore
+    /// // Bad
+    /// 2 ^ 16;
+    ///
+    /// // Good
+    /// 1 << 16;
+    /// 2i32.pow(16);
+    /// ```
+    pub XOR_USED_AS_POW,
+    correctness,
+    "use of `^` operator when exponentiation was intended"
+}
+
+declare_lint_pass!(XorUsedAsPow => [XOR_USED_AS_POW]);
+
+impl EarlyLintPass for XorUsedAsPow {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if_chain! {
+            if !in_external_macro(cx.sess, expr.span);
+            if let ExprKind::Binary(op, left, right) = &expr.node;
+            if BinOpKind::BitXor == op.node;
+            if let ExprKind::Lit(lit) = &left.node;
+            if let LitKind::Int(lhs, _) = lit.node;
+            if let ExprKind::Lit(lit) = &right.node;
+            if let LitKind::Int(rhs, _) = lit.node;
+            then {
+                if lhs == 2 {
+                    if rhs == 8 || rhs == 16 || rhs == 32 || rhs == 64 || rhs == 128 {
+                        span_lint_and_sugg(
+                            cx,
+                            XOR_USED_AS_POW,
+                            expr.span,
+                            "it appears you are trying to get the maximum value of an integer, but `^` is not an exponentiation operator",
+                            "try",
+                            format!("std::u{}::MAX", rhs),
+                            Applicability::MaybeIncorrect,
+                        )
+                    } else {
+                        span_lint_and_sugg(
+                            cx,
+                            XOR_USED_AS_POW,
+                            expr.span,
+                            "it appears you are trying to get a power of two, but `^` is not an exponentiation operator",
+                            "use a bitshift instead",
+                            format!("1 << {}", rhs),
+                            Applicability::MaybeIncorrect,
+                        )
+                    }
+                } else {
+                    span_help_and_lint(
+                        cx,
+                        XOR_USED_AS_POW,
+                        expr.span,
+                        "`^` is not an exponentiation operator but appears to have been used as one",
+                        "did you mean to use .pow()?"
+                    )
+                }
+            }
+        }
+    }
+}

src/lintlist/mod.rs

@@ -2853,6 +2853,13 @@ vec![
         deprecation: None,
         module: "transmute",
     },
+    Lint {
+        name: "xor_used_as_pow",
+        group: "correctness",
+        desc: "use of `^` operator when exponentiation was intended",
+        deprecation: None,
+        module: "xor_used_as_pow",
+    },
     Lint {
         name: "zero_divided_by_zero",
         group: "complexity",

tests/ui/xor_used_as_pow.rs

@@ -0,0 +1,15 @@
+#![warn(clippy::xor_used_as_pow)]
+
+fn main() {
+    // These should succeed
+    // With variables, it's not as clear whether the intention was exponentiation or not
+    let x = 15;
+    println!("{}", 2 ^ x);
+    let y = 2;
+    println!("{}", y ^ 16);
+
+    // These should fail
+    println!("{}", 2 ^ 16);
+    println!("{}", 2 ^ 7);
+    println!("{}", 9 ^ 3);
+}

tests/ui/xor_used_as_pow.stderr

@@ -0,0 +1,24 @@
+error: it appears you are trying to get the maximum value of an integer, but `^` is not an exponentiation operator
+  --> $DIR/xor_used_as_pow.rs:12:20
+   |
+LL |     println!("{}", 2 ^ 16);
+   |                    ^^^^^^ help: try: `std::u16::MAX`
+   |
+   = note: `-D clippy::xor-used-as-pow` implied by `-D warnings`
+
+error: it appears you are trying to get a power of two, but `^` is not an exponentiation operator
+  --> $DIR/xor_used_as_pow.rs:13:20
+   |
+LL |     println!("{}", 2 ^ 7);
+   |                    ^^^^^ help: use a bitshift instead: `1 << 7`
+
+error: `^` is not an exponentiation operator but appears to have been used as one
+  --> $DIR/xor_used_as_pow.rs:14:20
+   |
+LL |     println!("{}", 9 ^ 3);
+   |                    ^^^^^
+   |
+   = help: did you mean to use .pow()?
+
+error: aborting due to 3 previous errors
+