Adding new linting

Author: andrewpollack

CHANGELOG.md

@@ -3026,6 +3026,7 @@ Released 2018-09-13
 [`while_immutable_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_immutable_condition
 [`while_let_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_loop
 [`while_let_on_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_on_iterator
+[`while_let_some_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_some_result
 [`wildcard_dependencies`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_dependencies
 [`wildcard_enum_match_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_enum_match_arm
 [`wildcard_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports

clippy_lints/src/lib.rs

@@ -376,6 +376,7 @@ mod vec;
 mod vec_init_then_push;
 mod vec_resize_to_zero;
 mod verbose_file_reads;
+mod while_let_some_result;
 mod wildcard_dependencies;
 mod wildcard_imports;
 mod write;
@@ -988,6 +989,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         vec_init_then_push::VEC_INIT_THEN_PUSH,
         vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
         verbose_file_reads::VERBOSE_FILE_READS,
+        while_let_some_result::WHILE_LET_SOME_RESULT,
         wildcard_dependencies::WILDCARD_DEPENDENCIES,
         wildcard_imports::ENUM_GLOB_USE,
         wildcard_imports::WILDCARD_IMPORTS,
@@ -1468,6 +1470,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(vec::USELESS_VEC),
         LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
         LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+        LintId::of(while_let_some_result::WHILE_LET_SOME_RESULT),
         LintId::of(write::PRINTLN_EMPTY_STRING),
         LintId::of(write::PRINT_LITERAL),
         LintId::of(write::PRINT_WITH_NEWLINE),
@@ -1580,6 +1583,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
         LintId::of(unused_unit::UNUSED_UNIT),
         LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+        LintId::of(while_let_some_result::WHILE_LET_SOME_RESULT),
         LintId::of(write::PRINTLN_EMPTY_STRING),
         LintId::of(write::PRINT_LITERAL),
         LintId::of(write::PRINT_WITH_NEWLINE),
@@ -1972,6 +1976,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(|| box missing_inline::MissingInline);
     store.register_late_pass(move || box exhaustive_items::ExhaustiveItems);
     store.register_late_pass(|| box if_let_some_result::OkIfLet);
+    store.register_late_pass(|| box while_let_some_result::WhileLetSomeResult);
     store.register_late_pass(|| box partialeq_ne_impl::PartialEqNeImpl);
     store.register_late_pass(|| box unused_io_amount::UnusedIoAmount);
     let enum_variant_size_threshold = conf.enum_variant_size_threshold;

clippy_lints/src/while_let_some_result.rs

@@ -0,0 +1,70 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::method_chain_args;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::is_type_diagnostic_item;
+use if_chain::if_chain;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, MatchSource, PatKind, QPath};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for unnecessary `ok()` in `while let`.
+    ///
+    /// ### Why is this bad?
+    /// Calling `ok()` in `while let` is unnecessary, instead match
+    /// on `Ok(pat)`
+    ///
+    /// ### Example
+    /// ```ignore
+    /// while let Some(value) = iter.next().ok() {
+    ///     vec.push(value)
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```ignore
+    /// while let Ok(value) = iter.next() {
+    ///     vec.push(value)
+    /// }
+    /// ```
+    pub WHILE_LET_SOME_RESULT,
+    style,
+    "usage of `ok()` in `while let Some(pat)` statements is unnecessary, match on `Ok(pat)` instead"
+}
+
+declare_lint_pass!(WhileLetSomeResult => [WHILE_LET_SOME_RESULT]);
+
+impl<'tcx> LateLintPass<'tcx> for WhileLetSomeResult {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if_chain! { //begin checking variables
+            if let ExprKind::Match(op, body, MatchSource::WhileLetDesugar { .. }) = expr.kind; //test if expr is `while let`
+            if let ExprKind::MethodCall(_, ok_span, result_types, _) = op.kind; //check is expr.ok() has type Result<T,E>.ok(, _)
+            if let PatKind::TupleStruct(QPath::Resolved(_, x), y, _)  = body[0].pat.kind; //get operation
+            if method_chain_args(op, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized;
+            if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(&result_types[0]), sym::result_type);
+            if rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_path(x, false)) == "Some";
+
+            then {
+                let mut applicability = Applicability::MachineApplicable;
+                let some_expr_string = snippet_with_applicability(cx, y[0].span, "", &mut applicability);
+                let trimmed_ok = snippet_with_applicability(cx, op.span.until(ok_span), "", &mut applicability);
+                 let sugg = format!(
+                    "while let Ok({}) = {}",
+                    some_expr_string,
+                    trimmed_ok.trim().trim_end_matches('.'),
+                );
+                span_lint_and_sugg(
+                    cx,
+                    WHILE_LET_SOME_RESULT,
+                    expr.span.with_hi(op.span.hi()),
+                    "matching on `Some` with `ok()` is redundant",
+                    &format!("consider matching on `Ok({})` and removing the call to `ok` instead", some_expr_string),
+                    sugg,
+                    applicability,
+                );
+            }
+        }
+    }
+}

tests/ui/while_let_some_result.fixed

@@ -0,0 +1,37 @@
+// run-rustfix
+
+#![warn(clippy::while_let_some_result)]
+
+struct Wat {
+    counter: i32,
+}
+
+impl Wat {
+    fn next(&mut self) -> Result<i32, &str> {
+        self.counter += 1;
+        if self.counter < 5 {
+            Ok(self.counter)
+        } else {
+            Err("Oh no")
+        }
+    }
+}
+
+fn base_1(x: i32) {
+    let mut wat = Wat { counter: x };
+    while let Ok(a) = wat.next() {
+        println!("{}", a);
+    }
+}
+
+fn base_2(x: i32) {
+    let mut wat = Wat { counter: x };
+    while let Ok(a) = wat.next() {
+        println!("{}", a);
+    }
+}
+
+fn main() {
+    let _ = base_1(1);
+    let _ = base_2(2);
+}

tests/ui/while_let_some_result.rs

@@ -0,0 +1,37 @@
+// run-rustfix
+
+#![warn(clippy::while_let_some_result)]
+
+struct Wat {
+    counter: i32,
+}
+
+impl Wat {
+    fn next(&mut self) -> Result<i32, &str> {
+        self.counter += 1;
+        if self.counter < 5 {
+            Ok(self.counter)
+        } else {
+            Err("Oh no")
+        }
+    }
+}
+
+fn base_1(x: i32) {
+    let mut wat = Wat { counter: x };
+    while let Some(a) = wat.next().ok() {
+        println!("{}", a);
+    }
+}
+
+fn base_2(x: i32) {
+    let mut wat = Wat { counter: x };
+    while let Ok(a) = wat.next() {
+        println!("{}", a);
+    }
+}
+
+fn main() {
+    let _ = base_1(1);
+    let _ = base_2(2);
+}

tests/ui/while_let_some_result.stderr

@@ -0,0 +1,14 @@
+error: matching on `Some` with `ok()` is redundant
+  --> $DIR/while_let_some_result.rs:22:5
+   |
+LL |     while let Some(a) = wat.next().ok() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::while-let-some-result` implied by `-D warnings`
+help: consider matching on `Ok(a)` and removing the call to `ok` instead
+   |
+LL |     while let Ok(a) = wat.next() {
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to previous error
+