Auto merge of #4551 - mikerite:fix-ice-reporting, r=llogiq

[rust.git] / clippy_lints / src / open_options.rs

diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs
index fbece8226597fde66ef67148b499cf5f9aa75540..5a3af2c3773fdf31e1829778eca8de3eff665777 100644 (file)
--- a/clippy_lints/src/open_options.rs
+++ b/clippy_lints/src/open_options.rs
@@ -1,41 +1,37 @@
-use rustc::hir::{Expr, ExprLit, ExprMethodCall};
-use rustc::lint::*;
-use syntax::ast::LitKind;
-use syntax::codemap::{Span, Spanned};
 use crate::utils::{match_type, paths, span_lint, walk_ptrs_ty};
+use rustc::hir::{Expr, ExprKind};
+use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use rustc::{declare_lint_pass, declare_tool_lint};
+use syntax::ast::LitKind;
+use syntax::source_map::{Span, Spanned};
 
-/// **What it does:** Checks for duplicate open options as well as combinations
-/// that make no sense.
-///
-/// **Why is this bad?** In the best case, the code will be harder to read than
-/// necessary. I don't know the worst case.
-///
-/// **Known problems:** None.
-///
-/// **Example:**
-/// ```rust
-/// OpenOptions::new().read(true).truncate(true)
-/// ```
 declare_clippy_lint! {
+    /// **What it does:** Checks for duplicate open options as well as combinations
+    /// that make no sense.
+    ///
+    /// **Why is this bad?** In the best case, the code will be harder to read than
+    /// necessary. I don't know the worst case.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    /// ```rust
+    /// use std::fs::OpenOptions;
+    ///
+    /// OpenOptions::new().read(true).truncate(true);
+    /// ```
     pub NONSENSICAL_OPEN_OPTIONS,
     correctness,
     "nonsensical combination of options for opening a file"
 }
 
-#[derive(Copy, Clone)]
-pub struct NonSensical;
-
-impl LintPass for NonSensical {
-    fn get_lints(&self) -> LintArray {
-        lint_array!(NONSENSICAL_OPEN_OPTIONS)
-    }
-}
+declare_lint_pass!(OpenOptions => [NONSENSICAL_OPEN_OPTIONS]);
 
-impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSensical {
+impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OpenOptions {
     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
-        if let ExprMethodCall(ref path, _, ref arguments) = e.node {
+        if let ExprKind::MethodCall(ref path, _, ref arguments) = e.node {
             let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&arguments[0]));
-            if path.ident.name == "open" && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
+            if path.ident.name == sym!(open) && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
                 let mut options = Vec::new();
                 get_open_options(cx, &arguments[0], &mut options);
                 check_open_options(cx, &options, e.span);
@@ -60,18 +56,18 @@ enum OpenOption {
     Append,
 }
 
-fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOption, Argument)>) {
-    if let ExprMethodCall(ref path, _, ref arguments) = argument.node {
+fn get_open_options(cx: &LateContext<'_, '_>, argument: &Expr, options: &mut Vec<(OpenOption, Argument)>) {
+    if let ExprKind::MethodCall(ref path, _, ref arguments) = argument.node {
         let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&arguments[0]));
 
         // Only proceed if this is a call on some object of type std::fs::OpenOptions
         if match_type(cx, obj_ty, &paths::OPEN_OPTIONS) && arguments.len() >= 2 {
             let argument_option = match arguments[1].node {
-                ExprLit(ref span) => {
+                ExprKind::Lit(ref span) => {
                     if let Spanned {
                         node: LitKind::Bool(lit),
                         ..
-                    } = **span
+                    } = *span
                     {
                         if lit {
                             Argument::True
@@ -111,7 +107,7 @@ fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOp
     }
 }
 
-fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span: Span) {
+fn check_open_options(cx: &LateContext<'_, '_>, options: &[(OpenOption, Argument)], span: Span) {
     let (mut create, mut append, mut truncate, mut read, mut write) = (false, false, false, false, false);
     let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) =
         (false, false, false, false, false);
@@ -131,7 +127,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                 } else {
                     create = true
                 }
-                create_arg = create_arg || (arg == Argument::True);;
+                create_arg = create_arg || (arg == Argument::True);
             },
             (OpenOption::Append, arg) => {
                 if append {
@@ -144,7 +140,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                 } else {
                     append = true
                 }
-                append_arg = append_arg || (arg == Argument::True);;
+                append_arg = append_arg || (arg == Argument::True);
             },
             (OpenOption::Truncate, arg) => {
                 if truncate {
@@ -170,7 +166,7 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                 } else {
                     read = true
                 }
-                read_arg = read_arg || (arg == Argument::True);;
+                read_arg = read_arg || (arg == Argument::True);
             },
             (OpenOption::Write, arg) => {
                 if write {
@@ -183,13 +179,18 @@ fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span
                 } else {
                     write = true
                 }
-                write_arg = write_arg || (arg == Argument::True);;
+                write_arg = write_arg || (arg == Argument::True);
             },
         }
     }
 
     if read && truncate && read_arg && truncate_arg && !(write && write_arg) {
-        span_lint(cx, NONSENSICAL_OPEN_OPTIONS, span, "file opened with \"truncate\" and \"read\"");
+        span_lint(
+            cx,
+            NONSENSICAL_OPEN_OPTIONS,
+            span,
+            "file opened with \"truncate\" and \"read\"",
+        );
     }
     if append && truncate && append_arg && truncate_arg {
         span_lint(