-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.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);
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
_ => Argument::Unknown,
};
- match &*path.name.as_str() {
+ match &*path.ident.as_str() {
"create" => {
options.push((OpenOption::Create, argument_option));
},
}
}
-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);
} else {
create = true
}
- create_arg = create_arg || (arg == Argument::True);;
+ create_arg = create_arg || (arg == Argument::True);
},
(OpenOption::Append, arg) => {
if append {
} else {
append = true
}
- append_arg = append_arg || (arg == Argument::True);;
+ append_arg = append_arg || (arg == Argument::True);
},
(OpenOption::Truncate, arg) => {
if truncate {
} else {
read = true
}
- read_arg = read_arg || (arg == Argument::True);;
+ read_arg = read_arg || (arg == Argument::True);
},
(OpenOption::Write, arg) => {
if write {
} 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(