use crate::utils::{is_copy, match_def_path, paths, qpath_res, span_lint_and_note}; use if_chain::if_chain; use rustc_hir::{Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint}; declare_clippy_lint! { /// **What it does:** Checks for calls to `std::mem::drop` with a reference /// instead of an owned value. /// /// **Why is this bad?** Calling `drop` on a reference will only drop the /// reference itself, which is a no-op. It will not call the `drop` method (from /// the `Drop` trait implementation) on the underlying referenced value, which /// is likely what was intended. /// /// **Known problems:** None. /// /// **Example:** /// ```ignore /// let mut lock_guard = mutex.lock(); /// std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex /// // still locked /// operation_that_requires_mutex_to_be_unlocked(); /// ``` pub DROP_REF, correctness, "calls to `std::mem::drop` with a reference instead of an owned value" } declare_clippy_lint! { /// **What it does:** Checks for calls to `std::mem::forget` with a reference /// instead of an owned value. /// /// **Why is this bad?** Calling `forget` on a reference will only forget the /// reference itself, which is a no-op. It will not forget the underlying /// referenced /// value, which is likely what was intended. /// /// **Known problems:** None. /// /// **Example:** /// ```rust /// let x = Box::new(1); /// std::mem::forget(&x) // Should have been forget(x), x will still be dropped /// ``` pub FORGET_REF, correctness, "calls to `std::mem::forget` with a reference instead of an owned value" } declare_clippy_lint! { /// **What it does:** Checks for calls to `std::mem::drop` with a value /// that derives the Copy trait /// /// **Why is this bad?** Calling `std::mem::drop` [does nothing for types that /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the /// value will be copied and moved into the function on invocation. /// /// **Known problems:** None. /// /// **Example:** /// ```rust /// let x: i32 = 42; // i32 implements Copy /// std::mem::drop(x) // A copy of x is passed to the function, leaving the /// // original unaffected /// ``` pub DROP_COPY, correctness, "calls to `std::mem::drop` with a value that implements Copy" } declare_clippy_lint! { /// **What it does:** Checks for calls to `std::mem::forget` with a value that /// derives the Copy trait /// /// **Why is this bad?** Calling `std::mem::forget` [does nothing for types that /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html) since the /// value will be copied and moved into the function on invocation. /// /// An alternative, but also valid, explanation is that Copy types do not /// implement /// the Drop trait, which means they have no destructors. Without a destructor, /// there /// is nothing for `std::mem::forget` to ignore. /// /// **Known problems:** None. /// /// **Example:** /// ```rust /// let x: i32 = 42; // i32 implements Copy /// std::mem::forget(x) // A copy of x is passed to the function, leaving the /// // original unaffected /// ``` pub FORGET_COPY, correctness, "calls to `std::mem::forget` with a value that implements Copy" } const DROP_REF_SUMMARY: &str = "calls to `std::mem::drop` with a reference instead of an owned value. \ Dropping a reference does nothing."; const FORGET_REF_SUMMARY: &str = "calls to `std::mem::forget` with a reference instead of an owned value. \ Forgetting a reference does nothing."; const DROP_COPY_SUMMARY: &str = "calls to `std::mem::drop` with a value that implements `Copy`. \ Dropping a copy leaves the original intact."; const FORGET_COPY_SUMMARY: &str = "calls to `std::mem::forget` with a value that implements `Copy`. \ Forgetting a copy leaves the original intact."; declare_lint_pass!(DropForgetRef => [DROP_REF, FORGET_REF, DROP_COPY, FORGET_COPY]); impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DropForgetRef { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) { if_chain! { if let ExprKind::Call(ref path, ref args) = expr.kind; if let ExprKind::Path(ref qpath) = path.kind; if args.len() == 1; if let Some(def_id) = qpath_res(cx, qpath, path.hir_id).opt_def_id(); then { let lint; let msg; let arg = &args[0]; let arg_ty = cx.tables.expr_ty(arg); if let ty::Ref(..) = arg_ty.kind { if match_def_path(cx, def_id, &paths::DROP) { lint = DROP_REF; msg = DROP_REF_SUMMARY.to_string(); } else if match_def_path(cx, def_id, &paths::MEM_FORGET) { lint = FORGET_REF; msg = FORGET_REF_SUMMARY.to_string(); } else { return; } span_lint_and_note(cx, lint, expr.span, &msg, arg.span, &format!("argument has type `{}`", arg_ty)); } else if is_copy(cx, arg_ty) { if match_def_path(cx, def_id, &paths::DROP) { lint = DROP_COPY; msg = DROP_COPY_SUMMARY.to_string(); } else if match_def_path(cx, def_id, &paths::MEM_FORGET) { lint = FORGET_COPY; msg = FORGET_COPY_SUMMARY.to_string(); } else { return; } span_lint_and_note(cx, lint, expr.span, &msg, arg.span, &format!("argument has type {}", arg_ty)); } } } } }