X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Funwrap.rs;h=9949a086f93aa1cc2a70641afbfdf86752c05cff;hb=a7fe3b2ebb35e6bca78bc103a75966105981abc4;hp=6d209acef395761e69c2723f4e6e0aef9ce9157a;hpb=81821acd59a051b5fb0b6e6dc9eeac894c92d758;p=rust.git diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs index 6d209acef39..9949a086f93 100644 --- a/clippy_lints/src/unwrap.rs +++ b/clippy_lints/src/unwrap.rs @@ -1,38 +1,61 @@ -use rustc::lint::*; +use if_chain::if_chain; +use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; +use rustc::{declare_lint_pass, declare_tool_lint}; +use crate::utils::sym; +use crate::utils::{ + higher::if_block, in_macro_or_desugar, match_type, paths, span_lint_and_then, usage::is_potentially_mutated, +}; use rustc::hir::intravisit::*; use rustc::hir::*; -use syntax::ast::NodeId; -use syntax::codemap::Span; -use crate::utils::{in_macro, match_type, paths, usage::is_potentially_mutated}; +use syntax::source_map::Span; -/// **What it does:** Checks for calls of unwrap[_err]() that cannot fail. -/// -/// **Why is this bad?** Using `if let` or `match` is more idiomatic. -/// -/// **Known problems:** Limitations of the borrow checker might make unwrap() necessary sometimes? -/// -/// **Example:** -/// ```rust -/// if option.is_some() { -/// do_something_with(option.unwrap()) -/// } -/// ``` -/// -/// Could be written: -/// -/// ```rust -/// if let Some(value) = option { -/// do_something_with(value) -/// } -/// ``` declare_clippy_lint! { + /// **What it does:** Checks for calls of `unwrap[_err]()` that cannot fail. + /// + /// **Why is this bad?** Using `if let` or `match` is more idiomatic. + /// + /// **Known problems:** Limitations of the borrow checker might make unwrap() necessary sometimes? + /// + /// **Example:** + /// ```rust + /// if option.is_some() { + /// do_something_with(option.unwrap()) + /// } + /// ``` + /// + /// Could be written: + /// + /// ```rust + /// if let Some(value) = option { + /// do_something_with(value) + /// } + /// ``` pub UNNECESSARY_UNWRAP, - complexity, + nursery, "checks for calls of unwrap[_err]() that cannot fail" } -pub struct Pass; +declare_clippy_lint! { + /// **What it does:** Checks for calls of `unwrap[_err]()` that will always fail. + /// + /// **Why is this bad?** If panicking is desired, an explicit `panic!()` should be used. + /// + /// **Known problems:** This lint only checks `if` conditions not assignments. + /// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized. + /// + /// **Example:** + /// ```rust + /// if option.is_none() { + /// do_something_with(option.unwrap()) + /// } + /// ``` + /// + /// This code will always panic. The if condition should probably be inverted. + pub PANICKING_UNWRAP, + nursery, + "checks for calls of unwrap[_err]() that will always fail" +} /// Visitor that keeps track of which variables are unwrappable. struct UnwrappableVariablesVisitor<'a, 'tcx: 'a> { @@ -57,24 +80,24 @@ fn collect_unwrap_info<'a, 'tcx: 'a>( expr: &'tcx Expr, invert: bool, ) -> Vec> { - if let Expr_::ExprBinary(op, left, right) = &expr.node { + if let ExprKind::Binary(op, left, right) = &expr.node { match (invert, op.node) { - (false, BinOp_::BiAnd) | (false, BinOp_::BiBitAnd) | (true, BinOp_::BiOr) | (true, BinOp_::BiBitOr) => { + (false, BinOpKind::And) | (false, BinOpKind::BitAnd) | (true, BinOpKind::Or) | (true, BinOpKind::BitOr) => { let mut unwrap_info = collect_unwrap_info(cx, left, invert); unwrap_info.append(&mut collect_unwrap_info(cx, right, invert)); return unwrap_info; }, _ => (), } - } else if let Expr_::ExprUnary(UnNot, expr) = &expr.node { + } else if let ExprKind::Unary(UnNot, expr) = &expr.node { return collect_unwrap_info(cx, expr, !invert); } else { if_chain! { - if let Expr_::ExprMethodCall(method_name, _, args) = &expr.node; - if let Expr_::ExprPath(QPath::Resolved(None, path)) = &args[0].node; + if let ExprKind::MethodCall(method_name, _, args) = &expr.node; + if let ExprKind::Path(QPath::Resolved(None, path)) = &args[0].node; let ty = cx.tables.expr_ty(&args[0]); - if match_type(cx, ty, &paths::OPTION) || match_type(cx, ty, &paths::RESULT); - let name = method_name.name.as_str(); + if match_type(cx, ty, &*paths::OPTION) || match_type(cx, ty, &*paths::RESULT); + let name = method_name.ident.as_str(); if ["is_some", "is_none", "is_ok", "is_err"].contains(&&*name); then { assert!(args.len() == 1); @@ -110,7 +133,7 @@ fn visit_branch(&mut self, cond: &'tcx Expr, branch: &'tcx Expr, else_branch: bo impl<'a, 'tcx: 'a> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &'tcx Expr) { - if let Expr_::ExprIf(cond, then, els) = &expr.node { + if let Some((cond, then, els)) = if_block(&expr) { walk_expr(self, cond); self.visit_branch(cond, then, false); if let Some(els) = els { @@ -119,22 +142,33 @@ fn visit_expr(&mut self, expr: &'tcx Expr) { } else { // find `unwrap[_err]()` calls: if_chain! { - if let Expr_::ExprMethodCall(ref method_name, _, ref args) = expr.node; - if let Expr_::ExprPath(QPath::Resolved(None, ref path)) = args[0].node; - if ["unwrap", "unwrap_err"].contains(&&*method_name.name.as_str()); - let call_to_unwrap = method_name.name == "unwrap"; + if let ExprKind::MethodCall(ref method_name, _, ref args) = expr.node; + if let ExprKind::Path(QPath::Resolved(None, ref path)) = args[0].node; + if [*sym::unwrap, *sym::unwrap_err].contains(&method_name.ident.name); + let call_to_unwrap = method_name.ident.name == *sym::unwrap; if let Some(unwrappable) = self.unwrappables.iter() - .find(|u| u.ident.def == path.def && call_to_unwrap == u.safe_to_unwrap); + .find(|u| u.ident.res == path.res); then { - self.cx.span_lint_note( - UNNECESSARY_UNWRAP, - expr.span, - &format!("You checked before that `{}()` cannot fail. \ - Instead of checking and unwrapping, it's better to use `if let` or `match`.", - method_name.name), - unwrappable.check.span, - "the check is happening here", - ); + if call_to_unwrap == unwrappable.safe_to_unwrap { + span_lint_and_then( + self.cx, + UNNECESSARY_UNWRAP, + expr.span, + &format!("You checked before that `{}()` cannot fail. \ + Instead of checking and unwrapping, it's better to use `if let` or `match`.", + method_name.ident.name), + |db| { db.span_label(unwrappable.check.span, "the check is happening here"); }, + ); + } else { + span_lint_and_then( + self.cx, + PANICKING_UNWRAP, + expr.span, + &format!("This call to `{}()` will always panic.", + method_name.ident.name), + |db| { db.span_label(unwrappable.check.span, "because of this check"); }, + ); + } } } walk_expr(self, expr); @@ -142,17 +176,13 @@ fn visit_expr(&mut self, expr: &'tcx Expr) { } fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { - NestedVisitorMap::OnlyBodies(&self.cx.tcx.hir) + NestedVisitorMap::OnlyBodies(&self.cx.tcx.hir()) } } -impl<'a> LintPass for Pass { - fn get_lints(&self) -> LintArray { - lint_array!(UNNECESSARY_UNWRAP) - } -} +declare_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]); -impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Unwrap { fn check_fn( &mut self, cx: &LateContext<'a, 'tcx>, @@ -160,9 +190,9 @@ fn check_fn( decl: &'tcx FnDecl, body: &'tcx Body, span: Span, - fn_id: NodeId, + fn_id: HirId, ) { - if in_macro(span) { + if in_macro_or_desugar(span) { return; }