| use std::ops::ControlFlow; | |
| use clippy_utils::diagnostics::span_lint; | |
| use clippy_utils::res::MaybeDef; | |
| use clippy_utils::visitors::for_each_expr; | |
| use clippy_utils::{SpanlessEq, higher, peel_hir_expr_while, sym}; | |
| use rustc_hir::{Expr, ExprKind, UnOp}; | |
| use rustc_lint::{LateContext, LateLintPass}; | |
| use rustc_session::declare_lint_pass; | |
| use rustc_span::Span; | |
| use rustc_span::symbol::Symbol; | |
| declare_clippy_lint! { | |
| /// ### What it does | |
| /// Checks for usage of `contains` to see if a value is not present | |
| /// in a set like `HashSet` or `BTreeSet`, followed by an `insert`. | |
| /// | |
| /// ### Why is this bad? | |
| /// Using just `insert` and checking the returned `bool` is more efficient. | |
| /// | |
| /// ### Known problems | |
| /// In case the value that wants to be inserted is borrowed and also expensive or impossible | |
| /// to clone. In such a scenario, the developer might want to check with `contains` before inserting, | |
| /// to avoid the clone. In this case, it will report a false positive. | |
| /// | |
| /// ### Example | |
| /// ```rust | |
| /// use std::collections::HashSet; | |
| /// let mut set = HashSet::new(); | |
| /// let value = 5; | |
| /// if !set.contains(&value) { | |
| /// set.insert(value); | |
| /// println!("inserted {value:?}"); | |
| /// } | |
| /// ``` | |
| /// Use instead: | |
| /// ```rust | |
| /// use std::collections::HashSet; | |
| /// let mut set = HashSet::new(); | |
| /// let value = 5; | |
| /// if set.insert(&value) { | |
| /// println!("inserted {value:?}"); | |
| /// } | |
| /// ``` | |
| #[clippy::version = "1.81.0"] | |
| pub SET_CONTAINS_OR_INSERT, | |
| nursery, | |
| "call to `<set>::contains` followed by `<set>::insert`" | |
| } | |
| declare_lint_pass!(SetContainsOrInsert => [SET_CONTAINS_OR_INSERT]); | |
| impl<'tcx> LateLintPass<'tcx> for SetContainsOrInsert { | |
| fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { | |
| if !expr.span.from_expansion() | |
| && let Some(higher::If { | |
| cond: cond_expr, | |
| then: then_expr, | |
| .. | |
| }) = higher::If::hir(expr) | |
| && let Some((contains_expr, sym)) = try_parse_op_call(cx, cond_expr, sym::contains)//try_parse_contains(cx, cond_expr) | |
| && let Some(insert_expr) = find_insert_calls(cx, &contains_expr, then_expr) | |
| { | |
| span_lint( | |
| cx, | |
| SET_CONTAINS_OR_INSERT, | |
| vec![contains_expr.span, insert_expr.span], | |
| format!("usage of `{sym}::insert` after `{sym}::contains`"), | |
| ); | |
| } | |
| } | |
| } | |
| struct OpExpr<'tcx> { | |
| receiver: &'tcx Expr<'tcx>, | |
| value: &'tcx Expr<'tcx>, | |
| span: Span, | |
| } | |
| fn try_parse_op_call<'tcx>( | |
| cx: &LateContext<'tcx>, | |
| expr: &'tcx Expr<'_>, | |
| symbol: Symbol, | |
| ) -> Option<(OpExpr<'tcx>, Symbol)> { | |
| let expr = peel_hir_expr_while(expr, |e| { | |
| if let ExprKind::Unary(UnOp::Not, e) = e.kind { | |
| Some(e) | |
| } else { | |
| None | |
| } | |
| }); | |
| if let ExprKind::MethodCall(path, receiver, [value], span) = expr.kind { | |
| let value = value.peel_borrows(); | |
| let value = peel_hir_expr_while(value, |e| { | |
| if let ExprKind::Unary(UnOp::Deref, e) = e.kind { | |
| Some(e) | |
| } else { | |
| None | |
| } | |
| }); | |
| let receiver = receiver.peel_borrows(); | |
| let receiver_ty = cx.typeck_results().expr_ty(receiver).peel_refs(); | |
| if value.span.eq_ctxt(expr.span) && path.ident.name == symbol { | |
| for sym in &[sym::HashSet, sym::BTreeSet] { | |
| if receiver_ty.is_diag_item(cx, *sym) { | |
| return Some((OpExpr { receiver, value, span }, *sym)); | |
| } | |
| } | |
| } | |
| } | |
| None | |
| } | |
| fn is_set_mutated<'tcx>(cx: &LateContext<'tcx>, contains_expr: &OpExpr<'tcx>, expr: &'tcx Expr<'_>) -> bool { | |
| // Guard on type to avoid useless potentially expansive `SpanlessEq` checks | |
| cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr() | |
| && matches!( | |
| cx.typeck_results().expr_ty(expr).peel_refs().opt_diag_name(cx), | |
| Some(sym::HashSet | sym::BTreeSet) | |
| ) | |
| && SpanlessEq::new(cx).eq_expr(contains_expr.receiver, expr.peel_borrows()) | |
| } | |
| fn find_insert_calls<'tcx>( | |
| cx: &LateContext<'tcx>, | |
| contains_expr: &OpExpr<'tcx>, | |
| expr: &'tcx Expr<'_>, | |
| ) -> Option<OpExpr<'tcx>> { | |
| for_each_expr(cx, expr, |e| { | |
| if let Some((insert_expr, _)) = try_parse_op_call(cx, e, sym::insert) | |
| && SpanlessEq::new(cx).eq_expr(contains_expr.receiver, insert_expr.receiver) | |
| && SpanlessEq::new(cx).eq_expr(contains_expr.value, insert_expr.value) | |
| { | |
| return ControlFlow::Break(Some(insert_expr)); | |
| } | |
| if is_set_mutated(cx, contains_expr, e) { | |
| return ControlFlow::Break(None); | |
| } | |
| ControlFlow::Continue(()) | |
| }) | |
| .flatten() | |
| } |