Add known_log_bases lint

Add lint to detect logarithm function calls with explicit bases 2,
10 and e and suggest usage of methods `log2`, `log10` and `ln`.

Author: krishna-veerareddy

CHANGELOG.md

@@ -1058,6 +1058,7 @@ Released 2018-09-13
 [`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
 [`iterator_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iterator_step_by_zero
 [`just_underscores_and_digits`]: https://rust-lang.github.io/rust-clippy/master/index.html#just_underscores_and_digits
+[`known_log_bases`]: https://rust-lang.github.io/rust-clippy/master/index.html#known_log_bases
 [`large_digit_groups`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups
 [`large_enum_variant`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant
 [`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays

README.md

@@ -6,7 +6,7 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are 340 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+[There are 341 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
 
 We have a bunch of lint categories to allow you to choose how much Clippy is supposed to ~~annoy~~ help you:
 

clippy_lints/src/float_functions.rs

@@ -0,0 +1,94 @@
+use crate::consts::{constant, Constant};
+use crate::utils::*;
+use rustc::declare_lint_pass;
+use rustc::hir::*;
+use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc_errors::Applicability;
+use rustc_session::declare_tool_lint;
+use std::f32::consts as f32_consts;
+use std::f64::consts as f64_consts;
+
+declare_clippy_lint! {
+    /// **What it does:** Looks for calls to `std::{f32,f64}::log` with
+    /// bases 2, 10 and e and suggests usage of methods `log2`, `log10`
+    /// and `ln` instead
+    ///
+    /// **Why is this bad?** Using `std::{f32,f64}::log` with bases 2, 10
+    /// and e is less accurate than using the methods `log2`, `log10` and
+    /// `ln` respectively
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// use std::f32::consts::E;
+    ///
+    /// let a = 1f32.log(2.0);
+    /// let b = 1f32.log(10.0);
+    /// let c = 1f32.log(E);
+    /// ```
+    ///
+    /// can be written as
+    ///
+    /// ```rust
+    /// let a = 1f32.log2();
+    /// let b = 1f32.log10();
+    /// let c = 1f32.ln();
+    /// ```
+    pub KNOWN_LOG_BASES,
+    nursery,
+    "checks for logarithm function calls with bases 2, 10 and e"
+}
+
+declare_lint_pass!(FloatFunctions => [KNOWN_LOG_BASES]);
+
+fn check_log_base(cx: &LateContext<'_, '_>, expr: &Expr, args: &HirVec<Expr>) {
+    let recv = &args[0];
+    let arg = sugg::Sugg::hir(cx, recv, "..").maybe_par();
+    let mut needs_lint = false;
+    let mut suggestion = String::new();
+
+    if let Some((value, _)) = constant(cx, cx.tables, &args[1]) {
+        if Constant::F32(2.0) == value || Constant::F64(2.0) == value {
+            needs_lint = true;
+            suggestion = format!("{}.log2()", arg);
+        } else if Constant::F32(10.0) == value || Constant::F64(10.0) == value {
+            needs_lint = true;
+            suggestion = format!("{}.log10()", arg);
+        } else if Constant::F32(f32_consts::E) == value || Constant::F64(f64_consts::E) == value {
+            needs_lint = true;
+            suggestion = format!("{}.ln()", arg);
+        }
+    }
+
+    if needs_lint {
+        span_lint_and_sugg(
+            cx,
+            KNOWN_LOG_BASES,
+            expr.span,
+            "logarithm for bases 2, 10 and e can be computed more accurately",
+            "consider using",
+            suggestion,
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FloatFunctions {
+    fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
+        match &expr.kind {
+            ExprKind::MethodCall(ref path, _, args) => {
+                let recv_ty = cx.tables.expr_ty(&args[0]);
+
+                if recv_ty.is_floating_point() {
+                    match &*path.ident.name.as_str() {
+                        "log" => check_log_base(cx, expr, args),
+                        _ => {},
+                    }
+                }
+            },
+            _ => {},
+        }
+    }
+}

clippy_lints/src/lib.rs

@@ -200,6 +200,7 @@ pub mod excessive_precision;
 pub mod exit;
 pub mod explicit_write;
 pub mod fallible_impl_from;
+pub mod float_functions;
 pub mod format;
 pub mod formatting;
 pub mod functions;
@@ -520,6 +521,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
         &exit::EXIT,
         &explicit_write::EXPLICIT_WRITE,
         &fallible_impl_from::FALLIBLE_IMPL_FROM,
+        &float_functions::KNOWN_LOG_BASES,
         &format::USELESS_FORMAT,
         &formatting::POSSIBLE_MISSING_COMMA,
         &formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
@@ -968,6 +970,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
     store.register_late_pass(|| box to_digit_is_some::ToDigitIsSome);
     let array_size_threshold = conf.array_size_threshold;
     store.register_late_pass(move || box large_stack_arrays::LargeStackArrays::new(array_size_threshold));
+    store.register_late_pass(move || box float_functions::FloatFunctions);
     store.register_early_pass(|| box as_conversions::AsConversions);
     store.register_early_pass(|| box utils::internal_lints::ProduceIce);
 
@@ -1582,6 +1585,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
     store.register_group(true, "clippy::nursery", Some("clippy_nursery"), vec![
         LintId::of(&attrs::EMPTY_LINE_AFTER_OUTER_ATTR),
         LintId::of(&fallible_impl_from::FALLIBLE_IMPL_FROM),
+        LintId::of(&float_functions::KNOWN_LOG_BASES),
         LintId::of(&missing_const_for_fn::MISSING_CONST_FOR_FN),
         LintId::of(&mul_add::MANUAL_MUL_ADD),
         LintId::of(&mutex_atomic::MUTEX_INTEGER),

src/lintlist/mod.rs

@@ -6,7 +6,7 @@ pub use lint::Lint;
 pub use lint::LINT_LEVELS;
 
 // begin lint list, do not remove this comment, it’s used in `update_lints`
-pub const ALL_LINTS: [Lint; 340] = [
+pub const ALL_LINTS: [Lint; 341] = [
     Lint {
         name: "absurd_extreme_comparisons",
         group: "correctness",
@@ -896,6 +896,13 @@ pub const ALL_LINTS: [Lint; 340] = [
         deprecation: None,
         module: "non_expressive_names",
     },
+    Lint {
+        name: "known_log_bases",
+        group: "nursery",
+        desc: "checks for logarithm function calls with bases 2, 10 and e",
+        deprecation: None,
+        module: "float_functions",
+    },
     Lint {
         name: "large_digit_groups",
         group: "pedantic",

tests/ui/float_functions.rs

@@ -0,0 +1,21 @@
+#![allow(dead_code)]
+
+const TWO: f32 = 2.0;
+const E: f32 = std::f32::consts::E;
+
+#[warn(clippy::known_log_bases)]
+fn check_log_base() {
+    let x = 1f32;
+    let _ = x.log(2f32);
+    let _ = x.log(10f32);
+    let _ = x.log(std::f32::consts::E);
+    let _ = x.log(TWO);
+    let _ = x.log(E);
+
+    let x = 1f64;
+    let _ = x.log(2f64);
+    let _ = x.log(10f64);
+    let _ = x.log(std::f64::consts::E);
+}
+
+fn main() {}

tests/ui/float_functions.stderr

@@ -0,0 +1,52 @@
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/float_functions.rs:9:13
+   |
+LL |     let _ = x.log(2f32);
+   |             ^^^^^^^^^^^ help: consider using: `x.log2()`
+   |
+   = note: `-D clippy::known-log-bases` implied by `-D warnings`
+
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/float_functions.rs:10:13
+   |
+LL |     let _ = x.log(10f32);
+   |             ^^^^^^^^^^^^ help: consider using: `x.log10()`
+
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/float_functions.rs:11:13
+   |
+LL |     let _ = x.log(std::f32::consts::E);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
+
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/float_functions.rs:12:13
+   |
+LL |     let _ = x.log(TWO);
+   |             ^^^^^^^^^^ help: consider using: `x.log2()`
+
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/float_functions.rs:13:13
+   |
+LL |     let _ = x.log(E);
+   |             ^^^^^^^^ help: consider using: `x.ln()`
+
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/float_functions.rs:16:13
+   |
+LL |     let _ = x.log(2f64);
+   |             ^^^^^^^^^^^ help: consider using: `x.log2()`
+
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/float_functions.rs:17:13
+   |
+LL |     let _ = x.log(10f64);
+   |             ^^^^^^^^^^^^ help: consider using: `x.log10()`
+
+error: logarithm for bases 2, 10 and e can be computed more accurately
+  --> $DIR/float_functions.rs:18:13
+   |
+LL |     let _ = x.log(std::f64::consts::E);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
+
+error: aborting due to 8 previous errors
+