Update for rustc 1.19.0-nightly (4bf5c99af 2017-06-10).

[rust.git] / clippy_lints / src / drop_forget_ref.rs

diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 3950cdb6acf95d37358ce350fe47b1f1b7336940..c938f17cd4979c08244aed58949582bd5a2f698b 100644 (file)
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,7 +1,7 @@
 use rustc::lint::*;
 use rustc::ty;
 use rustc::hir::*;
-use utils::{match_def_path, paths, span_note_and_lint};
+use utils::{match_def_path, paths, span_note_and_lint, is_copy};
 
 /// **What it does:** Checks for calls to `std::mem::drop` with a reference
 /// instead of an owned value.
@@ -45,12 +45,65 @@
     "calls to `std::mem::forget` with a reference instead of an owned value"
 }
 
+/// **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
+/// ```
+declare_lint! {
+    pub DROP_COPY,
+    Warn,
+    "calls to `std::mem::drop` with a value that implements Copy"
+}
+
+/// **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
+/// ```
+declare_lint! {
+    pub FORGET_COPY,
+    Warn,
+    "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.";
+
 #[allow(missing_copy_implementations)]
 pub struct Pass;
 
 impl LintPass for Pass {
     fn get_lints(&self) -> LintArray {
-        lint_array!(DROP_REF, FORGET_REF)
+        lint_array!(DROP_REF, FORGET_REF, DROP_COPY, FORGET_COPY)
     }
 }
 
@@ -61,27 +114,42 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
             let ExprPath(ref qpath) = path.node,
             args.len() == 1,
         ], {
-            let def_id = cx.tcx.tables().qpath_def(qpath, path.id).def_id();
+            let def_id = cx.tables.qpath_def(qpath, path.id).def_id();
             let lint;
             let msg;
-            if match_def_path(cx, def_id, &paths::DROP) {
-                lint = DROP_REF;
-                msg = "call to `std::mem::drop` with a reference argument. \
-                       Dropping a reference does nothing";
-            } else if match_def_path(cx, def_id, &paths::MEM_FORGET) {
-                lint = FORGET_REF;
-                msg = "call to `std::mem::forget` with a reference argument. \
-                       Forgetting a reference does nothing";
-            } else {
-                return;
-            }
             let arg = &args[0];
-            let arg_ty = cx.tcx.tables().expr_ty(arg);
+            let arg_ty = cx.tables.expr_ty(arg);
+
             if let ty::TyRef(..) = arg_ty.sty {
+                if match_def_path(cx.tcx, def_id, &paths::DROP) {
+                    lint = DROP_REF;
+                    msg = DROP_REF_SUMMARY.to_string();
+                } else if match_def_path(cx.tcx, def_id, &paths::MEM_FORGET) {
+                    lint = FORGET_REF;
+                    msg = FORGET_REF_SUMMARY.to_string();
+                } else {
+                    return;
+                }
+                span_note_and_lint(cx,
+                                   lint,
+                                   expr.span,
+                                   &msg,
+                                   arg.span,
+                                   &format!("argument has type {}", arg_ty.sty));
+            } else if is_copy(cx, arg_ty) {
+                if match_def_path(cx.tcx, def_id, &paths::DROP) {
+                    lint = DROP_COPY;
+                    msg = DROP_COPY_SUMMARY.to_string();
+                } else if match_def_path(cx.tcx, def_id, &paths::MEM_FORGET) {
+                    lint = FORGET_COPY;
+                    msg = FORGET_COPY_SUMMARY.to_string();
+                } else {
+                    return;
+                }
                 span_note_and_lint(cx,
                                    lint,
                                    expr.span,
-                                   msg,
+                                   &msg,
                                    arg.span,
                                    &format!("argument has type {}", arg_ty.sty));
             }