Merge pull request #1963 from rust-lang-nursery/upstream

[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 9d0201b0d09093505999617b01ced14669a9ca8e..6ca04d40067a7697ec3436afc337cddd44c3d93e 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, is_copy};
+use utils::{is_copy, match_def_path, paths, span_note_and_lint};
 
 /// **What it does:** Checks for calls to `std::mem::drop` with a reference
 /// instead of an owned value.
@@ -16,7 +16,8 @@
 /// **Example:**
 /// ```rust
 /// let mut lock_guard = mutex.lock();
-/// std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex still locked
+/// std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex
+/// still locked
 /// operation_that_requires_mutex_to_be_unlocked();
 /// ```
 declare_lint! {
@@ -29,7 +30,8 @@
 /// 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
+/// reference itself, which is a no-op. It will not forget the underlying
+/// referenced
 /// value, which is likely what was intended.
 ///
 /// **Known problems:** None.
@@ -57,7 +59,8 @@
 /// **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
+/// std::mem::drop(x) // A copy of x is passed to the function, leaving the
+/// original unaffected
 /// ```
 declare_lint! {
     pub DROP_COPY,
@@ -72,8 +75,10 @@
 /// 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
+/// 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.
@@ -81,7 +86,8 @@
 /// **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
+/// std::mem::forget(x) // A copy of x is passed to the function, leaving the
+/// original unaffected
 /// ```
 declare_lint! {
     pub FORGET_COPY,
@@ -89,21 +95,21 @@
     "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.";
+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)
     }
 }
 
@@ -114,7 +120,7 @@ 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.tables.qpath_def(qpath, path.id).def_id();
+            let def_id = cx.tables.qpath_def(qpath, path.hir_id).def_id();
             let lint;
             let msg;
             let arg = &args[0];
@@ -135,8 +141,8 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
                                    expr.span,
                                    &msg,
                                    arg.span,
-                                   &format!("argument has type {}", arg_ty.sty));
-            } else if is_copy(cx, arg_ty, cx.tcx.hir.get_parent(arg.id)) {
+                                   &format!("argument has type {}", arg_ty));
+            } 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();
@@ -151,7 +157,7 @@ fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
                                    expr.span,
                                    &msg,
                                    arg.span,
-                                   &format!("argument has type {}", arg_ty.sty));
+                                   &format!("argument has type {}", arg_ty));
             }
         }}
     }