1 use rustc::hir::{Expr, ExprMethodCall, ExprLit};
3 use syntax::ast::LitKind;
4 use syntax::codemap::{Span, Spanned};
5 use utils::{match_type, paths, span_lint, walk_ptrs_ty_depth};
7 /// **What it does:** Checks for duplicate open options as well as combinations
8 /// that make no sense.
10 /// **Why is this bad?** In the best case, the code will be harder to read than
11 /// necessary. I don't know the worst case.
13 /// **Known problems:** None.
17 /// OpenOptions::new().read(true).truncate(true)
20 pub NONSENSICAL_OPEN_OPTIONS,
22 "nonsensical combination of options for opening a file"
27 pub struct NonSensical;
29 impl LintPass for NonSensical {
30 fn get_lints(&self) -> LintArray {
31 lint_array!(NONSENSICAL_OPEN_OPTIONS)
35 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSensical {
36 fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
37 if let ExprMethodCall(ref name, _, ref arguments) = e.node {
38 let (obj_ty, _) = walk_ptrs_ty_depth(cx.tables.expr_ty(&arguments[0]));
39 if &*name.node.as_str() == "open" && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
40 let mut options = Vec::new();
41 get_open_options(cx, &arguments[0], &mut options);
42 check_open_options(cx, &options, e.span);
48 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
64 fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOption, Argument)>) {
65 if let ExprMethodCall(ref name, _, ref arguments) = argument.node {
66 let (obj_ty, _) = walk_ptrs_ty_depth(cx.tables.expr_ty(&arguments[0]));
68 // Only proceed if this is a call on some object of type std::fs::OpenOptions
69 if match_type(cx, obj_ty, &paths::OPEN_OPTIONS) && arguments.len() >= 2 {
71 let argument_option = match arguments[1].node {
72 ExprLit(ref span) => {
73 if let Spanned { node: LitKind::Bool(lit), .. } = **span {
74 if lit { Argument::True } else { Argument::False }
76 return; // The function is called with a literal
77 // which is not a boolean literal. This is theoretically
78 // possible, but not very likely.
81 _ => Argument::Unknown,
84 match &*name.node.as_str() {
86 options.push((OpenOption::Create, argument_option));
89 options.push((OpenOption::Append, argument_option));
92 options.push((OpenOption::Truncate, argument_option));
95 options.push((OpenOption::Read, argument_option));
98 options.push((OpenOption::Write, argument_option));
103 get_open_options(cx, &arguments[0], options);
108 fn check_open_options(cx: &LateContext, options: &[(OpenOption, Argument)], span: Span) {
109 let (mut create, mut append, mut truncate, mut read, mut write) = (false, false, false, false, false);
110 let (mut create_arg, mut append_arg, mut truncate_arg, mut read_arg, mut write_arg) =
111 (false, false, false, false, false);
112 // This code is almost duplicated (oh, the irony), but I haven't found a way to unify it.
114 for option in options {
116 (OpenOption::Create, arg) => {
119 NONSENSICAL_OPEN_OPTIONS,
121 "the method \"create\" is called more than once");
125 create_arg = create_arg || (arg == Argument::True);;
127 (OpenOption::Append, arg) => {
130 NONSENSICAL_OPEN_OPTIONS,
132 "the method \"append\" is called more than once");
136 append_arg = append_arg || (arg == Argument::True);;
138 (OpenOption::Truncate, arg) => {
141 NONSENSICAL_OPEN_OPTIONS,
143 "the method \"truncate\" is called more than once");
147 truncate_arg = truncate_arg || (arg == Argument::True);
149 (OpenOption::Read, arg) => {
152 NONSENSICAL_OPEN_OPTIONS,
154 "the method \"read\" is called more than once");
158 read_arg = read_arg || (arg == Argument::True);;
160 (OpenOption::Write, arg) => {
163 NONSENSICAL_OPEN_OPTIONS,
165 "the method \"write\" is called more than once");
169 write_arg = write_arg || (arg == Argument::True);;
174 if read && truncate && read_arg && truncate_arg && !(write && write_arg) {
175 span_lint(cx, NONSENSICAL_OPEN_OPTIONS, span, "file opened with \"truncate\" and \"read\"");
177 if append && truncate && append_arg && truncate_arg {
179 NONSENSICAL_OPEN_OPTIONS,
181 "file opened with \"append\" and \"truncate\"");