2021-03-25 18:29:11 +00:00
|
|
|
use clippy_utils::diagnostics::span_lint_and_then;
|
2021-08-08 14:49:13 +00:00
|
|
|
use clippy_utils::higher;
|
2021-03-25 18:29:11 +00:00
|
|
|
use clippy_utils::ty::is_type_diagnostic_item;
|
2021-09-08 14:31:47 +00:00
|
|
|
use clippy_utils::{differing_macro_contexts, path_to_local, usage::is_potentially_mutated};
|
2018-07-19 08:00:54 +00:00
|
|
|
use if_chain::if_chain;
|
2021-09-08 14:31:47 +00:00
|
|
|
use rustc_errors::Applicability;
|
2020-02-21 08:39:38 +00:00
|
|
|
use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, NestedVisitorMap, Visitor};
|
2021-09-08 14:31:47 +00:00
|
|
|
use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, PathSegment, UnOp};
|
2020-01-12 06:08:41 +00:00
|
|
|
use rustc_lint::{LateContext, LateLintPass};
|
2020-03-30 09:02:14 +00:00
|
|
|
use rustc_middle::hir::map::Map;
|
|
|
|
use rustc_middle::lint::in_external_macro;
|
2020-05-17 15:36:26 +00:00
|
|
|
use rustc_middle::ty::Ty;
|
2020-01-11 11:37:08 +00:00
|
|
|
use rustc_session::{declare_lint_pass, declare_tool_lint};
|
2020-01-04 10:00:00 +00:00
|
|
|
use rustc_span::source_map::Span;
|
2020-11-05 13:29:48 +00:00
|
|
|
use rustc_span::sym;
|
2018-05-27 22:02:38 +00:00
|
|
|
|
|
|
|
declare_clippy_lint! {
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### What it does
|
|
|
|
/// Checks for calls of `unwrap[_err]()` that cannot fail.
|
2019-03-05 16:50:33 +00:00
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Why is this bad?
|
|
|
|
/// Using `if let` or `match` is more idiomatic.
|
2019-03-05 16:50:33 +00:00
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Example
|
2019-03-05 16:50:33 +00:00
|
|
|
/// ```rust
|
2019-08-01 10:53:20 +00:00
|
|
|
/// # let option = Some(0);
|
|
|
|
/// # fn do_something_with(_x: usize) {}
|
2019-03-05 16:50:33 +00:00
|
|
|
/// if option.is_some() {
|
|
|
|
/// do_something_with(option.unwrap())
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// Could be written:
|
|
|
|
///
|
|
|
|
/// ```rust
|
2019-08-01 10:53:20 +00:00
|
|
|
/// # let option = Some(0);
|
|
|
|
/// # fn do_something_with(_x: usize) {}
|
2019-03-05 16:50:33 +00:00
|
|
|
/// if let Some(value) = option {
|
|
|
|
/// do_something_with(value)
|
|
|
|
/// }
|
|
|
|
/// ```
|
2018-05-27 22:02:38 +00:00
|
|
|
pub UNNECESSARY_UNWRAP,
|
2019-07-30 07:50:56 +00:00
|
|
|
complexity,
|
2020-01-06 06:30:43 +00:00
|
|
|
"checks for calls of `unwrap[_err]()` that cannot fail"
|
2018-05-27 22:02:38 +00:00
|
|
|
}
|
|
|
|
|
2018-06-08 16:12:01 +00:00
|
|
|
declare_clippy_lint! {
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### What it does
|
|
|
|
/// Checks for calls of `unwrap[_err]()` that will always fail.
|
2019-03-05 16:50:33 +00:00
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Why is this bad?
|
|
|
|
/// If panicking is desired, an explicit `panic!()` should be used.
|
2019-03-05 16:50:33 +00:00
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Known problems
|
|
|
|
/// This lint only checks `if` conditions not assignments.
|
2019-03-05 16:50:33 +00:00
|
|
|
/// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.
|
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Example
|
2019-03-05 16:50:33 +00:00
|
|
|
/// ```rust
|
2019-08-01 10:53:20 +00:00
|
|
|
/// # let option = Some(0);
|
|
|
|
/// # fn do_something_with(_x: usize) {}
|
2019-03-05 16:50:33 +00:00
|
|
|
/// if option.is_none() {
|
|
|
|
/// do_something_with(option.unwrap())
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// This code will always panic. The if condition should probably be inverted.
|
2018-06-08 16:12:01 +00:00
|
|
|
pub PANICKING_UNWRAP,
|
2019-07-30 07:50:56 +00:00
|
|
|
correctness,
|
2020-01-06 06:30:43 +00:00
|
|
|
"checks for calls of `unwrap[_err]()` that will always fail"
|
2018-06-08 16:12:01 +00:00
|
|
|
}
|
|
|
|
|
2018-05-27 22:02:38 +00:00
|
|
|
/// Visitor that keeps track of which variables are unwrappable.
|
2019-06-19 18:36:23 +00:00
|
|
|
struct UnwrappableVariablesVisitor<'a, 'tcx> {
|
2018-05-27 22:02:38 +00:00
|
|
|
unwrappables: Vec<UnwrapInfo<'tcx>>,
|
2020-06-25 20:41:36 +00:00
|
|
|
cx: &'a LateContext<'tcx>,
|
2018-05-27 22:02:38 +00:00
|
|
|
}
|
2021-09-08 14:31:47 +00:00
|
|
|
|
|
|
|
/// What kind of unwrappable this is.
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
|
|
|
enum UnwrappableKind {
|
|
|
|
Option,
|
|
|
|
Result,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl UnwrappableKind {
|
|
|
|
fn success_variant_pattern(self) -> &'static str {
|
|
|
|
match self {
|
|
|
|
UnwrappableKind::Option => "Some(..)",
|
|
|
|
UnwrappableKind::Result => "Ok(..)",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn error_variant_pattern(self) -> &'static str {
|
|
|
|
match self {
|
|
|
|
UnwrappableKind::Option => "None",
|
|
|
|
UnwrappableKind::Result => "Err(..)",
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-27 22:02:38 +00:00
|
|
|
/// Contains information about whether a variable can be unwrapped.
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
|
|
|
struct UnwrapInfo<'tcx> {
|
|
|
|
/// The variable that is checked
|
2021-09-08 14:31:47 +00:00
|
|
|
local_id: HirId,
|
|
|
|
/// The if itself
|
|
|
|
if_expr: &'tcx Expr<'tcx>,
|
2018-05-27 22:02:38 +00:00
|
|
|
/// The check, like `x.is_ok()`
|
2019-12-27 07:12:26 +00:00
|
|
|
check: &'tcx Expr<'tcx>,
|
2021-09-08 14:31:47 +00:00
|
|
|
/// The check's name, like `is_ok`
|
|
|
|
check_name: &'tcx PathSegment<'tcx>,
|
2020-05-11 18:23:47 +00:00
|
|
|
/// The branch where the check takes place, like `if x.is_ok() { .. }`
|
|
|
|
branch: &'tcx Expr<'tcx>,
|
2018-05-27 22:02:38 +00:00
|
|
|
/// Whether `is_some()` or `is_ok()` was called (as opposed to `is_err()` or `is_none()`).
|
|
|
|
safe_to_unwrap: bool,
|
2021-09-08 14:31:47 +00:00
|
|
|
/// What kind of unwrappable this is.
|
|
|
|
kind: UnwrappableKind,
|
|
|
|
/// If the check is the entire condition (`if x.is_ok()`) or only a part of it (`foo() &&
|
|
|
|
/// x.is_ok()`)
|
|
|
|
is_entire_condition: bool,
|
2018-05-27 22:02:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Collects the information about unwrappable variables from an if condition
|
|
|
|
/// The `invert` argument tells us whether the condition is negated.
|
2020-06-25 20:41:36 +00:00
|
|
|
fn collect_unwrap_info<'tcx>(
|
|
|
|
cx: &LateContext<'tcx>,
|
2021-09-08 14:31:47 +00:00
|
|
|
if_expr: &'tcx Expr<'_>,
|
2019-12-27 07:12:26 +00:00
|
|
|
expr: &'tcx Expr<'_>,
|
2020-05-11 18:23:47 +00:00
|
|
|
branch: &'tcx Expr<'_>,
|
2018-05-27 22:02:38 +00:00
|
|
|
invert: bool,
|
2021-09-08 14:31:47 +00:00
|
|
|
is_entire_condition: bool,
|
2018-05-27 22:02:38 +00:00
|
|
|
) -> Vec<UnwrapInfo<'tcx>> {
|
2020-06-25 20:41:36 +00:00
|
|
|
fn is_relevant_option_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: &str) -> bool {
|
2021-10-02 23:51:01 +00:00
|
|
|
is_type_diagnostic_item(cx, ty, sym::Option) && ["is_some", "is_none"].contains(&method_name)
|
2020-05-17 15:36:26 +00:00
|
|
|
}
|
|
|
|
|
2020-06-25 20:41:36 +00:00
|
|
|
fn is_relevant_result_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: &str) -> bool {
|
2021-10-02 23:51:01 +00:00
|
|
|
is_type_diagnostic_item(cx, ty, sym::Result) && ["is_ok", "is_err"].contains(&method_name)
|
2020-05-17 15:36:26 +00:00
|
|
|
}
|
|
|
|
|
2019-09-27 15:16:06 +00:00
|
|
|
if let ExprKind::Binary(op, left, right) = &expr.kind {
|
2018-05-27 22:02:38 +00:00
|
|
|
match (invert, op.node) {
|
2020-06-09 14:36:01 +00:00
|
|
|
(false, BinOpKind::And | BinOpKind::BitAnd) | (true, BinOpKind::Or | BinOpKind::BitOr) => {
|
2021-09-08 14:31:47 +00:00
|
|
|
let mut unwrap_info = collect_unwrap_info(cx, if_expr, left, branch, invert, false);
|
|
|
|
unwrap_info.append(&mut collect_unwrap_info(cx, if_expr, right, branch, invert, false));
|
2018-05-27 22:02:38 +00:00
|
|
|
return unwrap_info;
|
|
|
|
},
|
|
|
|
_ => (),
|
|
|
|
}
|
2021-02-09 08:15:53 +00:00
|
|
|
} else if let ExprKind::Unary(UnOp::Not, expr) = &expr.kind {
|
2021-09-08 14:31:47 +00:00
|
|
|
return collect_unwrap_info(cx, if_expr, expr, branch, !invert, false);
|
2018-05-27 22:02:38 +00:00
|
|
|
} else {
|
|
|
|
if_chain! {
|
2020-06-09 21:44:04 +00:00
|
|
|
if let ExprKind::MethodCall(method_name, _, args, _) = &expr.kind;
|
2021-09-08 14:31:47 +00:00
|
|
|
if let Some(local_id) = path_to_local(&args[0]);
|
2020-07-17 08:47:04 +00:00
|
|
|
let ty = cx.typeck_results().expr_ty(&args[0]);
|
2018-06-28 13:46:58 +00:00
|
|
|
let name = method_name.ident.as_str();
|
2020-05-17 15:36:26 +00:00
|
|
|
if is_relevant_option_call(cx, ty, &name) || is_relevant_result_call(cx, ty, &name);
|
2018-05-27 22:02:38 +00:00
|
|
|
then {
|
|
|
|
assert!(args.len() == 1);
|
|
|
|
let unwrappable = match name.as_ref() {
|
|
|
|
"is_some" | "is_ok" => true,
|
|
|
|
"is_err" | "is_none" => false,
|
|
|
|
_ => unreachable!(),
|
|
|
|
};
|
|
|
|
let safe_to_unwrap = unwrappable != invert;
|
2021-10-02 23:51:01 +00:00
|
|
|
let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
|
2021-09-08 14:31:47 +00:00
|
|
|
UnwrappableKind::Option
|
|
|
|
} else {
|
|
|
|
UnwrappableKind::Result
|
|
|
|
};
|
|
|
|
|
|
|
|
return vec![
|
|
|
|
UnwrapInfo {
|
|
|
|
local_id,
|
|
|
|
if_expr,
|
|
|
|
check: expr,
|
|
|
|
check_name: method_name,
|
|
|
|
branch,
|
|
|
|
safe_to_unwrap,
|
|
|
|
kind,
|
|
|
|
is_entire_condition,
|
|
|
|
}
|
|
|
|
]
|
2018-05-27 22:02:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Vec::new()
|
|
|
|
}
|
|
|
|
|
2019-06-19 18:36:23 +00:00
|
|
|
impl<'a, 'tcx> UnwrappableVariablesVisitor<'a, 'tcx> {
|
2021-09-08 14:31:47 +00:00
|
|
|
fn visit_branch(
|
|
|
|
&mut self,
|
|
|
|
if_expr: &'tcx Expr<'_>,
|
|
|
|
cond: &'tcx Expr<'_>,
|
|
|
|
branch: &'tcx Expr<'_>,
|
|
|
|
else_branch: bool,
|
|
|
|
) {
|
2018-05-27 22:02:38 +00:00
|
|
|
let prev_len = self.unwrappables.len();
|
2021-09-08 14:31:47 +00:00
|
|
|
for unwrap_info in collect_unwrap_info(self.cx, if_expr, cond, branch, else_branch, true) {
|
|
|
|
if is_potentially_mutated(unwrap_info.local_id, cond, self.cx)
|
|
|
|
|| is_potentially_mutated(unwrap_info.local_id, branch, self.cx)
|
2018-05-27 22:02:38 +00:00
|
|
|
{
|
|
|
|
// if the variable is mutated, we don't know whether it can be unwrapped:
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
self.unwrappables.push(unwrap_info);
|
|
|
|
}
|
|
|
|
walk_expr(self, branch);
|
|
|
|
self.unwrappables.truncate(prev_len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-19 18:36:23 +00:00
|
|
|
impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
|
2020-01-09 07:13:22 +00:00
|
|
|
type Map = Map<'tcx>;
|
|
|
|
|
2019-12-27 07:12:26 +00:00
|
|
|
fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
|
2020-02-03 19:01:42 +00:00
|
|
|
// Shouldn't lint when `expr` is in macro.
|
2020-02-04 20:38:26 +00:00
|
|
|
if in_external_macro(self.cx.tcx.sess, expr.span) {
|
2020-02-03 19:01:42 +00:00
|
|
|
return;
|
|
|
|
}
|
2021-08-08 14:49:13 +00:00
|
|
|
if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr) {
|
2018-05-27 22:02:38 +00:00
|
|
|
walk_expr(self, cond);
|
2021-09-08 14:31:47 +00:00
|
|
|
self.visit_branch(expr, cond, then, false);
|
2021-08-08 14:49:13 +00:00
|
|
|
if let Some(else_inner) = r#else {
|
2021-09-08 14:31:47 +00:00
|
|
|
self.visit_branch(expr, cond, else_inner, true);
|
2018-05-27 22:02:38 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// find `unwrap[_err]()` calls:
|
|
|
|
if_chain! {
|
2021-04-08 15:50:13 +00:00
|
|
|
if let ExprKind::MethodCall(method_name, _, args, _) = expr.kind;
|
2021-09-08 14:31:47 +00:00
|
|
|
if let Some(id) = path_to_local(&args[0]);
|
|
|
|
if [sym::unwrap, sym::expect, sym!(unwrap_err)].contains(&method_name.ident.name);
|
|
|
|
let call_to_unwrap = [sym::unwrap, sym::expect].contains(&method_name.ident.name);
|
2018-05-27 22:02:38 +00:00
|
|
|
if let Some(unwrappable) = self.unwrappables.iter()
|
2021-09-08 14:31:47 +00:00
|
|
|
.find(|u| u.local_id == id);
|
2020-05-11 18:23:47 +00:00
|
|
|
// Span contexts should not differ with the conditional branch
|
|
|
|
if !differing_macro_contexts(unwrappable.branch.span, expr.span);
|
|
|
|
if !differing_macro_contexts(unwrappable.branch.span, unwrappable.check.span);
|
2018-05-27 22:02:38 +00:00
|
|
|
then {
|
2018-06-08 16:12:01 +00:00
|
|
|
if call_to_unwrap == unwrappable.safe_to_unwrap {
|
2021-09-08 14:31:47 +00:00
|
|
|
let is_entire_condition = unwrappable.is_entire_condition;
|
|
|
|
let unwrappable_variable_name = self.cx.tcx.hir().name(unwrappable.local_id);
|
|
|
|
let suggested_pattern = if call_to_unwrap {
|
|
|
|
unwrappable.kind.success_variant_pattern()
|
|
|
|
} else {
|
|
|
|
unwrappable.kind.error_variant_pattern()
|
|
|
|
};
|
|
|
|
|
2018-06-08 16:12:01 +00:00
|
|
|
span_lint_and_then(
|
|
|
|
self.cx,
|
|
|
|
UNNECESSARY_UNWRAP,
|
|
|
|
expr.span,
|
2021-09-08 14:31:47 +00:00
|
|
|
&format!(
|
|
|
|
"called `{}` on `{}` after checking its variant with `{}`",
|
|
|
|
method_name.ident.name,
|
|
|
|
unwrappable_variable_name,
|
|
|
|
unwrappable.check_name.ident.as_str(),
|
|
|
|
),
|
|
|
|
|diag| {
|
|
|
|
if is_entire_condition {
|
|
|
|
diag.span_suggestion(
|
|
|
|
unwrappable.check.span.with_lo(unwrappable.if_expr.span.lo()),
|
|
|
|
"try",
|
|
|
|
format!(
|
|
|
|
"if let {} = {}",
|
|
|
|
suggested_pattern,
|
|
|
|
unwrappable_variable_name,
|
|
|
|
),
|
|
|
|
// We don't track how the unwrapped value is used inside the
|
|
|
|
// block or suggest deleting the unwrap, so we can't offer a
|
|
|
|
// fixable solution.
|
|
|
|
Applicability::Unspecified,
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
diag.span_label(unwrappable.check.span, "the check is happening here");
|
|
|
|
diag.help("try using `if let` or `match`");
|
|
|
|
}
|
|
|
|
},
|
2018-06-08 16:12:01 +00:00
|
|
|
);
|
|
|
|
} else {
|
|
|
|
span_lint_and_then(
|
|
|
|
self.cx,
|
2018-06-08 18:38:39 +00:00
|
|
|
PANICKING_UNWRAP,
|
2018-06-08 16:12:01 +00:00
|
|
|
expr.span,
|
2020-08-11 13:43:21 +00:00
|
|
|
&format!("this call to `{}()` will always panic",
|
2018-06-28 13:46:58 +00:00
|
|
|
method_name.ident.name),
|
2020-04-17 06:08:00 +00:00
|
|
|
|diag| { diag.span_label(unwrappable.check.span, "because of this check"); },
|
2018-06-08 16:12:01 +00:00
|
|
|
);
|
|
|
|
}
|
2018-05-27 22:02:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
walk_expr(self, expr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-15 22:41:20 +00:00
|
|
|
fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
|
|
|
|
NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
|
2018-05-27 22:02:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-08 20:43:55 +00:00
|
|
|
declare_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]);
|
2018-05-27 22:02:38 +00:00
|
|
|
|
2020-06-25 20:41:36 +00:00
|
|
|
impl<'tcx> LateLintPass<'tcx> for Unwrap {
|
2018-05-27 22:02:38 +00:00
|
|
|
fn check_fn(
|
|
|
|
&mut self,
|
2020-06-25 20:41:36 +00:00
|
|
|
cx: &LateContext<'tcx>,
|
2018-05-27 22:02:38 +00:00
|
|
|
kind: FnKind<'tcx>,
|
2019-12-30 04:02:10 +00:00
|
|
|
decl: &'tcx FnDecl<'_>,
|
2019-12-22 14:42:41 +00:00
|
|
|
body: &'tcx Body<'_>,
|
2018-05-27 22:02:38 +00:00
|
|
|
span: Span,
|
2019-02-20 10:11:11 +00:00
|
|
|
fn_id: HirId,
|
2018-05-27 22:02:38 +00:00
|
|
|
) {
|
2019-08-19 16:30:32 +00:00
|
|
|
if span.from_expansion() {
|
2018-05-27 22:02:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut v = UnwrappableVariablesVisitor {
|
|
|
|
cx,
|
|
|
|
unwrappables: Vec::new(),
|
|
|
|
};
|
|
|
|
|
|
|
|
walk_fn(&mut v, kind, decl, body.id(), span, fn_id);
|
|
|
|
}
|
|
|
|
}
|