2021-03-25 13:29:11 -05:00
|
|
|
use clippy_utils::diagnostics::span_lint_and_then;
|
|
|
|
use clippy_utils::source::snippet;
|
2021-04-22 04:31:13 -05:00
|
|
|
use clippy_utils::{contains_return, in_macro, is_lang_ctor, return_ty, visitors::find_all_ret_expressions};
|
2020-11-23 06:51:04 -06:00
|
|
|
use if_chain::if_chain;
|
|
|
|
use rustc_errors::Applicability;
|
|
|
|
use rustc_hir::intravisit::FnKind;
|
2021-04-22 04:31:13 -05:00
|
|
|
use rustc_hir::LangItem::{OptionSome, ResultOk};
|
2021-01-15 03:56:44 -06:00
|
|
|
use rustc_hir::{Body, ExprKind, FnDecl, HirId, Impl, ItemKind, Node};
|
2020-11-23 06:51:04 -06:00
|
|
|
use rustc_lint::{LateContext, LateLintPass};
|
2021-02-25 04:25:22 -06:00
|
|
|
use rustc_middle::ty;
|
2020-11-23 06:51:04 -06:00
|
|
|
use rustc_session::{declare_lint_pass, declare_tool_lint};
|
2020-12-20 10:19:49 -06:00
|
|
|
use rustc_span::symbol::sym;
|
2020-11-23 06:51:04 -06:00
|
|
|
use rustc_span::Span;
|
|
|
|
|
|
|
|
declare_clippy_lint! {
|
|
|
|
/// **What it does:** Checks for private functions that only return `Ok` or `Some`.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** It is not meaningful to wrap values when no `None` or `Err` is returned.
|
|
|
|
///
|
2021-02-25 04:25:22 -06:00
|
|
|
/// **Known problems:** There can be false positives if the function signature is designed to
|
|
|
|
/// fit some external requirement.
|
2020-11-23 06:51:04 -06:00
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// fn get_cool_number(a: bool, b: bool) -> Option<i32> {
|
|
|
|
/// if a && b {
|
|
|
|
/// return Some(50);
|
|
|
|
/// }
|
|
|
|
/// if a {
|
|
|
|
/// Some(0)
|
|
|
|
/// } else {
|
|
|
|
/// Some(10)
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
/// Use instead:
|
|
|
|
/// ```rust
|
|
|
|
/// fn get_cool_number(a: bool, b: bool) -> i32 {
|
|
|
|
/// if a && b {
|
|
|
|
/// return 50;
|
|
|
|
/// }
|
|
|
|
/// if a {
|
|
|
|
/// 0
|
|
|
|
/// } else {
|
|
|
|
/// 10
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
pub UNNECESSARY_WRAPS,
|
2021-02-25 04:25:22 -06:00
|
|
|
pedantic,
|
2020-11-23 06:51:04 -06:00
|
|
|
"functions that only return `Ok` or `Some`"
|
|
|
|
}
|
|
|
|
|
|
|
|
declare_lint_pass!(UnnecessaryWraps => [UNNECESSARY_WRAPS]);
|
|
|
|
|
|
|
|
impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
|
|
|
|
fn check_fn(
|
|
|
|
&mut self,
|
|
|
|
cx: &LateContext<'tcx>,
|
|
|
|
fn_kind: FnKind<'tcx>,
|
|
|
|
fn_decl: &FnDecl<'tcx>,
|
|
|
|
body: &Body<'tcx>,
|
|
|
|
span: Span,
|
|
|
|
hir_id: HirId,
|
|
|
|
) {
|
2021-02-25 04:25:22 -06:00
|
|
|
// Abort if public function/method or closure.
|
2020-11-23 06:51:04 -06:00
|
|
|
match fn_kind {
|
2020-11-27 02:24:42 -06:00
|
|
|
FnKind::ItemFn(.., visibility) | FnKind::Method(.., Some(visibility)) => {
|
2020-11-23 06:51:04 -06:00
|
|
|
if visibility.node.is_pub() {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
},
|
2020-11-27 02:24:42 -06:00
|
|
|
FnKind::Closure => return,
|
2021-03-25 13:29:11 -05:00
|
|
|
FnKind::Method(..) => (),
|
2020-11-23 06:51:04 -06:00
|
|
|
}
|
|
|
|
|
2021-02-25 04:25:22 -06:00
|
|
|
// Abort if the method is implementing a trait or of it a trait method.
|
2020-11-23 06:51:04 -06:00
|
|
|
if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
|
2020-12-20 10:19:49 -06:00
|
|
|
if matches!(
|
|
|
|
item.kind,
|
2020-11-22 16:46:21 -06:00
|
|
|
ItemKind::Impl(Impl { of_trait: Some(_), .. }) | ItemKind::Trait(..)
|
2020-12-20 10:19:49 -06:00
|
|
|
) {
|
2020-11-23 06:51:04 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-25 04:25:22 -06:00
|
|
|
// Get the wrapper and inner types, if can't, abort.
|
2021-04-22 04:31:13 -05:00
|
|
|
let (return_type_label, lang_item, inner_type) = if let ty::Adt(adt_def, subst) = return_ty(cx, hir_id).kind() {
|
2021-02-25 04:25:22 -06:00
|
|
|
if cx.tcx.is_diagnostic_item(sym::option_type, adt_def.did) {
|
2021-04-22 04:31:13 -05:00
|
|
|
("Option", OptionSome, subst.type_at(0))
|
2021-02-25 04:25:22 -06:00
|
|
|
} else if cx.tcx.is_diagnostic_item(sym::result_type, adt_def.did) {
|
2021-04-22 04:31:13 -05:00
|
|
|
("Result", ResultOk, subst.type_at(0))
|
2021-02-25 04:25:22 -06:00
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
2020-11-23 06:51:04 -06:00
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
|
2021-02-25 04:25:22 -06:00
|
|
|
// Check if all return expression respect the following condition and collect them.
|
2020-11-23 06:51:04 -06:00
|
|
|
let mut suggs = Vec::new();
|
|
|
|
let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
|
|
|
|
if_chain! {
|
|
|
|
if !in_macro(ret_expr.span);
|
2021-02-25 04:25:22 -06:00
|
|
|
// Check if a function call.
|
2021-04-22 04:31:13 -05:00
|
|
|
if let ExprKind::Call(func, [arg]) = ret_expr.kind;
|
2021-02-25 04:25:22 -06:00
|
|
|
// Check if OPTION_SOME or RESULT_OK, depending on return type.
|
2021-04-22 04:31:13 -05:00
|
|
|
if let ExprKind::Path(qpath) = &func.kind;
|
|
|
|
if is_lang_ctor(cx, qpath, lang_item);
|
2021-02-25 04:25:22 -06:00
|
|
|
// Make sure the function argument does not contain a return expression.
|
2021-04-22 04:31:13 -05:00
|
|
|
if !contains_return(arg);
|
2020-11-23 06:51:04 -06:00
|
|
|
then {
|
2021-02-25 04:25:22 -06:00
|
|
|
suggs.push(
|
|
|
|
(
|
|
|
|
ret_expr.span,
|
|
|
|
if inner_type.is_unit() {
|
|
|
|
"".to_string()
|
|
|
|
} else {
|
2021-04-22 04:31:13 -05:00
|
|
|
snippet(cx, arg.span.source_callsite(), "..").to_string()
|
2021-02-25 04:25:22 -06:00
|
|
|
}
|
|
|
|
)
|
|
|
|
);
|
2020-11-23 06:51:04 -06:00
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
if can_sugg && !suggs.is_empty() {
|
2021-02-25 04:25:22 -06:00
|
|
|
let (lint_msg, return_type_sugg_msg, return_type_sugg, body_sugg_msg) = if inner_type.is_unit() {
|
|
|
|
(
|
|
|
|
"this function's return value is unnecessary".to_string(),
|
|
|
|
"remove the return type...".to_string(),
|
|
|
|
snippet(cx, fn_decl.output.span(), "..").to_string(),
|
|
|
|
"...and then remove returned values",
|
2020-11-23 06:51:04 -06:00
|
|
|
)
|
2021-02-25 04:25:22 -06:00
|
|
|
} else {
|
|
|
|
(
|
|
|
|
format!(
|
|
|
|
"this function's return value is unnecessarily wrapped by `{}`",
|
|
|
|
return_type_label
|
|
|
|
),
|
|
|
|
format!("remove `{}` from the return type...", return_type_label),
|
|
|
|
inner_type.to_string(),
|
|
|
|
"...and then change returning expressions",
|
|
|
|
)
|
|
|
|
};
|
|
|
|
|
|
|
|
span_lint_and_then(cx, UNNECESSARY_WRAPS, span, lint_msg.as_str(), |diag| {
|
|
|
|
diag.span_suggestion(
|
|
|
|
fn_decl.output.span(),
|
|
|
|
return_type_sugg_msg.as_str(),
|
|
|
|
return_type_sugg,
|
|
|
|
Applicability::MaybeIncorrect,
|
|
|
|
);
|
|
|
|
diag.multipart_suggestion(body_sugg_msg, suggs, Applicability::MaybeIncorrect);
|
|
|
|
});
|
2020-11-23 06:51:04 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|