-use rustc::lint::*;
-use rustc::ty;
-use rustc::hir::*;
-use utils::{match_def_path, paths, span_note_and_lint, is_copy};
+// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::rustc::hir::*;
+use crate::rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
+use crate::rustc::ty;
+use crate::rustc::{declare_tool_lint, lint_array};
+use crate::utils::{is_copy, match_def_path, opt_def_id, paths, span_note_and_lint};
+use if_chain::if_chain;
/// **What it does:** Checks for calls to `std::mem::drop` with a reference
/// instead of an owned value.
/// ```rust
/// let mut lock_guard = mutex.lock();
/// std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex
-/// still locked
+/// // still locked
/// operation_that_requires_mutex_to_be_unlocked();
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub DROP_REF,
- Warn,
+ correctness,
"calls to `std::mem::drop` with a reference instead of an owned value"
}
/// let x = Box::new(1);
/// std::mem::forget(&x) // Should have been forget(x), x will still be dropped
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub FORGET_REF,
- Warn,
+ correctness,
"calls to `std::mem::forget` with a reference instead of an owned value"
}
///
/// **Example:**
/// ```rust
-/// let x:i32 = 42; // i32 implements Copy
+/// let x: i32 = 42; // i32 implements Copy
/// std::mem::drop(x) // A copy of x is passed to the function, leaving the
-/// original unaffected
+/// // original unaffected
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub DROP_COPY,
- Warn,
+ correctness,
"calls to `std::mem::drop` with a value that implements Copy"
}
///
/// **Example:**
/// ```rust
-/// let x:i32 = 42; // i32 implements Copy
+/// let x: i32 = 42; // i32 implements Copy
/// std::mem::forget(x) // A copy of x is passed to the function, leaving the
-/// original unaffected
+/// // original unaffected
/// ```
-declare_lint! {
+declare_clippy_lint! {
pub FORGET_COPY,
- Warn,
+ 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.";
+ 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.";
+ 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.";
+ 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.";
+ Forgetting a copy leaves the original intact.";
-#[allow(missing_copy_implementations)]
pub struct Pass;
impl LintPass for Pass {
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
- if_let_chain!{[
- let ExprCall(ref path, ref args) = expr.node,
- let ExprPath(ref qpath) = path.node,
- args.len() == 1,
- ], {
- let def_id = cx.tables.qpath_def(qpath, path.hir_id).def_id();
- let lint;
- let msg;
- let arg = &args[0];
- let arg_ty = cx.tables.expr_ty(arg);
+ if_chain! {
+ if let ExprKind::Call(ref path, ref args) = expr.node;
+ if let ExprKind::Path(ref qpath) = path.node;
+ if args.len() == 1;
+ if let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, path.hir_id));
+ then {
+ let lint;
+ let msg;
+ let arg = &args[0];
+ 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));
- } 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;
+ if let ty::Ref(..) = 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));
+ } 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,
+ arg.span,
+ &format!("argument has type {}", arg_ty));
}
- span_note_and_lint(cx,
- lint,
- expr.span,
- &msg,
- arg.span,
- &format!("argument has type {}", arg_ty));
}
- }}
+ }
}
}
projects / rust.git / blobdiff