rust-clippy/clippy_lints/src/open_options.rs

218 lines
7.3 KiB
Rust
Raw Normal View History

2018-10-06 16:18:06 +00:00
// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
2018-05-30 08:15:50 +00:00
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_tool_lint, lint_array};
use syntax::ast::LitKind;
use syntax::source_map::{Span, Spanned};
2015-10-07 11:15:14 +00:00
/// **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.
///
2016-07-15 22:25:44 +00:00
/// **Example:**
/// ```rust
/// OpenOptions::new().read(true).truncate(true)
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
2015-10-07 11:15:14 +00:00
pub NONSENSICAL_OPEN_OPTIONS,
2018-03-28 13:24:26 +00:00
correctness,
2015-10-07 15:15:44 +00:00
"nonsensical combination of options for opening a file"
2015-10-07 11:15:14 +00:00
}
2017-08-09 07:30:56 +00:00
#[derive(Copy, Clone)]
2016-06-10 14:17:20 +00:00
pub struct NonSensical;
2015-10-07 11:15:14 +00:00
2016-06-10 14:17:20 +00:00
impl LintPass for NonSensical {
2015-10-07 11:15:14 +00:00
fn get_lints(&self) -> LintArray {
lint_array!(NONSENSICAL_OPEN_OPTIONS)
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSensical {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
2018-07-12 07:30:57 +00:00
if let ExprKind::MethodCall(ref path, _, ref arguments) = e.node {
let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&arguments[0]));
2018-06-28 13:46:58 +00:00
if path.ident.name == "open" && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
2015-10-07 11:15:14 +00:00
let mut options = Vec::new();
get_open_options(cx, &arguments[0], &mut options);
check_open_options(cx, &options, e.span);
}
}
}
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
2015-10-07 11:15:14 +00:00
enum Argument {
True,
False,
2016-01-04 04:26:12 +00:00
Unknown,
2015-10-07 11:15:14 +00:00
}
#[derive(Debug)]
enum OpenOption {
2015-10-07 15:15:44 +00:00
Write,
Read,
Truncate,
Create,
2016-01-04 04:26:12 +00:00
Append,
2015-10-07 11:15:14 +00:00
}
2018-07-23 11:01:12 +00:00
fn get_open_options(cx: &LateContext<'_, '_>, argument: &Expr, options: &mut Vec<(OpenOption, Argument)>) {
2018-07-12 07:30:57 +00:00
if let ExprKind::MethodCall(ref path, _, ref arguments) = argument.node {
let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&arguments[0]));
2016-01-04 04:26:12 +00:00
2015-10-07 11:15:14 +00:00
// Only proceed if this is a call on some object of type std::fs::OpenOptions
2016-04-14 16:13:15 +00:00
if match_type(cx, obj_ty, &paths::OPEN_OPTIONS) && arguments.len() >= 2 {
2015-10-07 11:15:14 +00:00
let argument_option = match arguments[1].node {
2018-07-12 07:30:57 +00:00
ExprKind::Lit(ref span) => {
2017-09-05 09:33:04 +00:00
if let Spanned {
node: LitKind::Bool(lit),
..
} = **span
{
if lit {
Argument::True
} else {
Argument::False
}
2015-10-07 11:15:14 +00:00
} else {
return; // The function is called with a literal
2017-11-04 19:55:56 +00:00
// which is not a boolean literal. This is theoretically
// possible, but not very likely.
2015-10-07 11:15:14 +00:00
}
2016-12-20 17:21:30 +00:00
},
2016-01-04 04:26:12 +00:00
_ => Argument::Unknown,
2015-10-07 11:15:14 +00:00
};
2016-01-04 04:26:12 +00:00
2018-06-28 13:46:58 +00:00
match &*path.ident.as_str() {
2015-10-07 11:15:14 +00:00
"create" => {
2015-10-07 15:15:44 +00:00
options.push((OpenOption::Create, argument_option));
2016-12-20 17:21:30 +00:00
},
2015-10-07 11:15:14 +00:00
"append" => {
2015-10-07 15:15:44 +00:00
options.push((OpenOption::Append, argument_option));
2016-12-20 17:21:30 +00:00
},
2015-10-07 11:15:14 +00:00
"truncate" => {
2015-10-07 15:15:44 +00:00
options.push((OpenOption::Truncate, argument_option));
2016-12-20 17:21:30 +00:00
},
2015-10-07 11:15:14 +00:00
"read" => {
2015-10-07 15:15:44 +00:00
options.push((OpenOption::Read, argument_option));
2016-12-20 17:21:30 +00:00
},
2015-10-07 11:15:14 +00:00
"write" => {
2015-10-07 15:15:44 +00:00
options.push((OpenOption::Write, argument_option));
2016-12-20 17:21:30 +00:00
},
2016-04-14 18:14:03 +00:00
_ => (),
2015-10-07 11:15:14 +00:00
}
2016-01-04 04:26:12 +00:00
2015-10-07 11:15:14 +00:00
get_open_options(cx, &arguments[0], options);
}
}
}
2018-07-23 11:01:12 +00:00
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);
2016-12-20 17:21:30 +00:00
let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) =
(false, false, false, false, false);
2017-08-09 07:30:56 +00:00
// This code is almost duplicated (oh, the irony), but I haven't found a way to
// unify it.
for option in options {
match *option {
(OpenOption::Create, arg) => {
if create {
2017-08-09 07:30:56 +00:00
span_lint(
cx,
NONSENSICAL_OPEN_OPTIONS,
span,
"the method \"create\" is called more than once",
);
} else {
create = true
}
create_arg = create_arg || (arg == Argument::True);;
2016-12-20 17:21:30 +00:00
},
(OpenOption::Append, arg) => {
if append {
2017-08-09 07:30:56 +00:00
span_lint(
cx,
NONSENSICAL_OPEN_OPTIONS,
span,
"the method \"append\" is called more than once",
);
} else {
append = true
}
append_arg = append_arg || (arg == Argument::True);;
2016-12-20 17:21:30 +00:00
},
(OpenOption::Truncate, arg) => {
if truncate {
2017-08-09 07:30:56 +00:00
span_lint(
cx,
NONSENSICAL_OPEN_OPTIONS,
span,
"the method \"truncate\" is called more than once",
);
} else {
truncate = true
}
truncate_arg = truncate_arg || (arg == Argument::True);
2016-12-20 17:21:30 +00:00
},
(OpenOption::Read, arg) => {
if read {
2017-08-09 07:30:56 +00:00
span_lint(
cx,
NONSENSICAL_OPEN_OPTIONS,
span,
"the method \"read\" is called more than once",
);
} else {
read = true
}
read_arg = read_arg || (arg == Argument::True);;
2016-12-20 17:21:30 +00:00
},
(OpenOption::Write, arg) => {
if write {
2017-08-09 07:30:56 +00:00
span_lint(
cx,
NONSENSICAL_OPEN_OPTIONS,
span,
"the method \"write\" is called more than once",
);
} else {
write = true
}
write_arg = write_arg || (arg == Argument::True);;
2016-12-20 17:21:30 +00:00
},
}
2015-10-07 11:15:14 +00:00
}
if read && truncate && read_arg && truncate_arg && !(write && write_arg) {
2018-11-27 20:14:15 +00:00
span_lint(
cx,
NONSENSICAL_OPEN_OPTIONS,
span,
"file opened with \"truncate\" and \"read\"",
);
2015-10-07 11:15:14 +00:00
}
if append && truncate && append_arg && truncate_arg {
2017-08-09 07:30:56 +00:00
span_lint(
cx,
NONSENSICAL_OPEN_OPTIONS,
span,
"file opened with \"append\" and \"truncate\"",
);
2015-10-07 11:15:14 +00:00
}
}