2020-10-02 09:21:17 +00:00
|
|
|
use crate::utils::{
|
|
|
|
is_type_diagnostic_item, match_qpath, paths, return_ty, snippet, span_lint_and_then,
|
|
|
|
visitors::find_all_ret_expressions,
|
|
|
|
};
|
2020-09-19 17:03:14 +00:00
|
|
|
use if_chain::if_chain;
|
|
|
|
use rustc_errors::Applicability;
|
2020-10-02 09:21:17 +00:00
|
|
|
use rustc_hir::intravisit::FnKind;
|
2020-09-19 17:03:14 +00:00
|
|
|
use rustc_hir::*;
|
|
|
|
use rustc_lint::{LateContext, LateLintPass};
|
2020-10-02 09:21:17 +00:00
|
|
|
use rustc_middle::ty::subst::GenericArgKind;
|
2020-09-19 17:03:14 +00:00
|
|
|
use rustc_session::{declare_lint_pass, declare_tool_lint};
|
|
|
|
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.
|
|
|
|
///
|
|
|
|
/// **Known problems:** Since this lint changes function type signature, you may need to
|
2020-09-22 18:06:52 +00:00
|
|
|
/// adjust some code at callee side.
|
2020-09-19 17:03:14 +00:00
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
///
|
|
|
|
/// ```rust
|
2020-09-20 15:06:25 +00:00
|
|
|
/// fn get_cool_number(a: bool, b: bool) -> Option<i32> {
|
2020-09-19 17:03:14 +00:00
|
|
|
/// if a && b {
|
|
|
|
/// return Some(50);
|
|
|
|
/// }
|
|
|
|
/// if a {
|
|
|
|
/// Some(0)
|
|
|
|
/// } else {
|
|
|
|
/// Some(10)
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
/// Use instead:
|
|
|
|
/// ```rust
|
2020-09-20 15:06:25 +00:00
|
|
|
/// fn get_cool_number(a: bool, b: bool) -> i32 {
|
2020-09-19 17:03:14 +00:00
|
|
|
/// if a && b {
|
|
|
|
/// return 50;
|
|
|
|
/// }
|
|
|
|
/// if a {
|
|
|
|
/// 0
|
|
|
|
/// } else {
|
|
|
|
/// 10
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
pub UNNECESSARY_WRAP,
|
|
|
|
complexity,
|
|
|
|
"functions that only return `Ok` or `Some`"
|
|
|
|
}
|
|
|
|
|
|
|
|
declare_lint_pass!(UnnecessaryWrap => [UNNECESSARY_WRAP]);
|
|
|
|
|
|
|
|
impl<'tcx> LateLintPass<'tcx> for UnnecessaryWrap {
|
|
|
|
fn check_fn(
|
|
|
|
&mut self,
|
|
|
|
cx: &LateContext<'tcx>,
|
|
|
|
fn_kind: FnKind<'tcx>,
|
|
|
|
fn_decl: &FnDecl<'tcx>,
|
|
|
|
body: &Body<'tcx>,
|
|
|
|
span: Span,
|
|
|
|
hir_id: HirId,
|
|
|
|
) {
|
|
|
|
if_chain! {
|
|
|
|
if let FnKind::ItemFn(.., visibility, _) = fn_kind;
|
|
|
|
if visibility.node.is_pub();
|
|
|
|
then {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-26 06:39:39 +00:00
|
|
|
let (return_type, path) = if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(option_type)) {
|
|
|
|
("Option", &paths::OPTION_SOME)
|
2020-09-22 17:53:55 +00:00
|
|
|
} else if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym!(result_type)) {
|
2020-09-26 06:39:39 +00:00
|
|
|
("Result", &paths::RESULT_OK)
|
2020-09-22 17:53:55 +00:00
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut suggs = Vec::new();
|
|
|
|
let can_sugg = find_all_ret_expressions(cx, &body.value, |ret_expr| {
|
|
|
|
if_chain! {
|
|
|
|
if let ExprKind::Call(ref func, ref args) = ret_expr.kind;
|
|
|
|
if let ExprKind::Path(ref qpath) = func.kind;
|
|
|
|
if match_qpath(qpath, path);
|
|
|
|
if args.len() == 1;
|
|
|
|
then {
|
|
|
|
suggs.push((ret_expr.span, snippet(cx, args[0].span.source_callsite(), "..").to_string()));
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
2020-09-19 17:03:14 +00:00
|
|
|
}
|
|
|
|
}
|
2020-09-22 17:53:55 +00:00
|
|
|
});
|
2020-09-19 17:03:14 +00:00
|
|
|
|
2020-09-22 17:53:55 +00:00
|
|
|
if can_sugg {
|
2020-09-19 17:03:14 +00:00
|
|
|
span_lint_and_then(
|
|
|
|
cx,
|
|
|
|
UNNECESSARY_WRAP,
|
|
|
|
span,
|
2020-10-12 10:21:04 +00:00
|
|
|
format!("this function's return value is unnecessarily wrapped by `{}`, return_type)",
|
2020-09-26 06:39:39 +00:00
|
|
|
|diag| {
|
|
|
|
let inner_ty = return_ty(cx, hir_id)
|
|
|
|
.walk()
|
|
|
|
.skip(1) // skip `std::option::Option` or `std::result::Result`
|
|
|
|
.take(1) // take the first outermost inner type
|
|
|
|
.filter_map(|inner| match inner.unpack() {
|
|
|
|
GenericArgKind::Type(inner_ty) => Some(inner_ty.to_string()),
|
|
|
|
_ => None,
|
|
|
|
});
|
|
|
|
inner_ty.for_each(|inner_ty| {
|
|
|
|
diag.span_suggestion(
|
|
|
|
fn_decl.output.span(),
|
|
|
|
format!("remove `{}` from the return type...", return_type).as_str(),
|
|
|
|
inner_ty,
|
|
|
|
Applicability::MachineApplicable,
|
|
|
|
);
|
|
|
|
});
|
2020-09-22 18:42:58 +00:00
|
|
|
diag.multipart_suggestion(
|
2020-09-26 06:39:39 +00:00
|
|
|
"...and change the returning expressions",
|
|
|
|
suggs,
|
2020-09-22 18:42:58 +00:00
|
|
|
Applicability::MachineApplicable,
|
2020-09-19 17:03:14 +00:00
|
|
|
);
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|