1 use clippy_utils::diagnostics::span_lint_and_sugg;
2 use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
3 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
4 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
5 use clippy_utils::{contains_return, is_trait_item, last_path_segment};
6 use if_chain::if_chain;
7 use rustc_errors::Applicability;
9 use rustc_lint::LateContext;
10 use rustc_span::source_map::Span;
11 use rustc_span::symbol::{kw, sym, Symbol};
14 use super::OR_FUN_CALL;
16 /// Checks for the `OR_FUN_CALL` lint.
17 #[allow(clippy::too_many_lines)]
18 pub(super) fn check<'tcx>(
19 cx: &LateContext<'tcx>,
23 receiver: &'tcx hir::Expr<'_>,
24 args: &'tcx [hir::Expr<'_>],
26 /// Checks for `unwrap_or(T::new())`, `unwrap_or(T::default())`,
27 /// `or_insert(T::new())` or `or_insert(T::default())`.
28 #[allow(clippy::too_many_arguments)]
29 fn check_unwrap_or_default(
38 let is_default_default = || is_trait_item(cx, fun, sym::Default);
40 let implements_default = |arg, default_trait_id| {
41 let arg_ty = cx.typeck_results().expr_ty(arg);
42 implements_trait(cx, arg_ty, default_trait_id, &[])
47 if let Some(sugg) = match name {
48 "unwrap_or" => Some("unwrap_or_default"),
49 "or_insert" => Some("or_default"),
52 if let hir::ExprKind::Path(ref qpath) = fun.kind;
53 if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
54 let path = last_path_segment(qpath).ident.name;
55 // needs to target Default::default in particular or be *::new and have a Default impl
57 if (matches!(path, kw::Default) && is_default_default())
58 || (matches!(path, sym::new) && implements_default(arg, default_trait_id));
64 method_span.with_hi(span.hi()),
65 &format!("use of `{name}` followed by a call to `{path}`"),
68 Applicability::MachineApplicable,
78 /// Checks for `*or(foo())`.
79 #[allow(clippy::too_many_arguments)]
80 fn check_general_case<'tcx>(
81 cx: &LateContext<'tcx>,
84 self_expr: &hir::Expr<'_>,
85 arg: &'tcx hir::Expr<'_>,
86 // `Some` if fn has second argument
87 second_arg: Option<&hir::Expr<'_>>,
89 // None if lambda is required
90 fun_span: Option<Span>,
92 // (path, fn_has_argument, methods, suffix)
93 const KNOW_TYPES: [(Symbol, bool, &[&str], &str); 4] = [
94 (sym::BTreeEntry, false, &["or_insert"], "with"),
95 (sym::HashMapEntry, false, &["or_insert"], "with"),
96 (sym::Option, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
97 (sym::Result, true, &["or", "unwrap_or"], "else"),
101 if KNOW_TYPES.iter().any(|k| k.2.contains(&name));
103 if switch_to_lazy_eval(cx, arg);
104 if !contains_return(arg);
106 let self_ty = cx.typeck_results().expr_ty(self_expr);
108 if let Some(&(_, fn_has_arguments, poss, suffix)) =
109 KNOW_TYPES.iter().find(|&&i| is_type_diagnostic_item(cx, self_ty, i.0));
111 if poss.contains(&name);
115 let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
116 (false, Some(fun_span)) => (fun_span, false),
117 _ => (arg.span, true),
120 let format_span = |span: Span| {
121 let not_macro_argument_snippet = snippet_with_macro_callsite(cx, span, "..");
122 let snip = if not_macro_argument_snippet == "vec![]" {
123 let macro_expanded_snipped = snippet(cx, snippet_span, "..");
124 match macro_expanded_snipped.strip_prefix("$crate::vec::") {
125 Some(stripped) => Cow::Owned(stripped.to_owned()),
126 None => macro_expanded_snipped,
129 not_macro_argument_snippet
135 let snip = format_span(snippet_span);
136 let snip = if use_lambda {
137 let l_arg = if fn_has_arguments { "_" } else { "" };
138 format!("|{l_arg}| {snip}")
143 if let Some(f) = second_arg {
144 let f = format_span(f.span);
145 format!("{snip}, {f}")
150 let span_replace_word = method_span.with_hi(span.hi());
155 &format!("use of `{name}` followed by a function call"),
157 format!("{name}_{suffix}({sugg})"),
158 Applicability::HasPlaceholders,
164 let extract_inner_arg = |arg: &'tcx hir::Expr<'_>| {
165 if let hir::ExprKind::Block(
180 if let [arg] = args {
181 let inner_arg = extract_inner_arg(arg);
182 match inner_arg.kind {
183 hir::ExprKind::Call(fun, or_args) => {
184 let or_has_args = !or_args.is_empty();
185 if !check_unwrap_or_default(cx, name, fun, arg, or_has_args, expr.span, method_span) {
186 let fun_span = if or_has_args { None } else { Some(fun.span) };
187 check_general_case(cx, name, method_span, receiver, arg, None, expr.span, fun_span);
190 hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
191 check_general_case(cx, name, method_span, receiver, arg, None, expr.span, None);
197 // `map_or` takes two arguments
198 if let [arg, lambda] = args {
199 let inner_arg = extract_inner_arg(arg);
200 if let hir::ExprKind::Call(fun, or_args) = inner_arg.kind {
201 let fun_span = if or_args.is_empty() { Some(fun.span) } else { None };
202 check_general_case(cx, name, method_span, receiver, arg, Some(lambda), expr.span, fun_span);