1 use clippy_utils::diagnostics::span_lint_and_then;
2 use clippy_utils::source::snippet_with_context;
3 use clippy_utils::{match_def_path, path_def_id, paths};
4 use rustc_errors::Applicability;
5 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, UnOp};
6 use rustc_lint::{LateContext, LateLintPass};
7 use rustc_session::{declare_lint_pass, declare_tool_lint};
8 use rustc_span::{Span, SyntaxContext};
10 declare_clippy_lint! {
12 /// Checks for calls to `core::mem::swap` where either parameter is derived from a pointer
14 /// ### Why is this bad?
15 /// When at least one parameter to `swap` is derived from a pointer it may overlap with the
16 /// other. This would then lead to undefined behavior.
20 /// unsafe fn swap(x: &[*mut u32], y: &[*mut u32]) {
21 /// for (&x, &y) in x.iter().zip(y) {
22 /// core::mem::swap(&mut *x, &mut *y);
28 /// unsafe fn swap(x: &[*mut u32], y: &[*mut u32]) {
29 /// for (&x, &y) in x.iter().zip(y) {
30 /// core::ptr::swap(x, y);
34 #[clippy::version = "1.63.0"]
37 "call to `mem::swap` using pointer derived references"
39 declare_lint_pass!(SwapPtrToRef => [SWAP_PTR_TO_REF]);
41 impl LateLintPass<'_> for SwapPtrToRef {
42 fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
43 if let ExprKind::Call(fn_expr, [arg1, arg2]) = e.kind
44 && let Some(fn_id) = path_def_id(cx, fn_expr)
45 && match_def_path(cx, fn_id, &paths::MEM_SWAP)
46 && let ctxt = e.span.ctxt()
47 && let (from_ptr1, arg1_span) = is_ptr_to_ref(cx, arg1, ctxt)
48 && let (from_ptr2, arg2_span) = is_ptr_to_ref(cx, arg2, ctxt)
49 && (from_ptr1 || from_ptr2)
55 "call to `core::mem::swap` with a parameter derived from a raw pointer",
57 if !((from_ptr1 && arg1_span.is_none()) || (from_ptr2 && arg2_span.is_none())) {
58 let mut app = Applicability::MachineApplicable;
59 let snip1 = snippet_with_context(cx, arg1_span.unwrap_or(arg1.span), ctxt, "..", &mut app).0;
60 let snip2 = snippet_with_context(cx, arg2_span.unwrap_or(arg2.span), ctxt, "..", &mut app).0;
61 diag.span_suggestion(e.span, "use ptr::swap", format!("core::ptr::swap({}, {})", snip1, snip2), app);
69 /// Checks if the expression converts a mutable pointer to a mutable reference. If it is, also
70 /// returns the span of the pointer expression if it's suitable for making a suggestion.
71 fn is_ptr_to_ref(cx: &LateContext<'_>, e: &Expr<'_>, ctxt: SyntaxContext) -> (bool, Option<Span>) {
72 if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, borrowed_expr) = e.kind
73 && let ExprKind::Unary(UnOp::Deref, derefed_expr) = borrowed_expr.kind
74 && cx.typeck_results().expr_ty(derefed_expr).is_unsafe_ptr()
76 (true, (borrowed_expr.span.ctxt() == ctxt || derefed_expr.span.ctxt() == ctxt).then_some(derefed_expr.span))