@@ -7,102 +7,6 @@ use rustc_lint::{LateContext, LateLintPass};
77use rustc_session:: { declare_lint_pass, declare_tool_lint} ;
88use rustc_span:: sym;
99
10- declare_clippy_lint ! {
11- /// ### What it does
12- /// Checks for calls to `std::mem::drop` with a reference
13- /// instead of an owned value.
14- ///
15- /// ### Why is this bad?
16- /// Calling `drop` on a reference will only drop the
17- /// reference itself, which is a no-op. It will not call the `drop` method (from
18- /// the `Drop` trait implementation) on the underlying referenced value, which
19- /// is likely what was intended.
20- ///
21- /// ### Example
22- /// ```ignore
23- /// let mut lock_guard = mutex.lock();
24- /// std::mem::drop(&lock_guard) // Should have been drop(lock_guard), mutex
25- /// // still locked
26- /// operation_that_requires_mutex_to_be_unlocked();
27- /// ```
28- [ clippy:: version = "pre 1.29.0" ]
29- pub DROP_REF ,
30- correctness,
31- "calls to `std::mem::drop` with a reference instead of an owned value"
32- }
33-
34- declare_clippy_lint ! {
35- /// ### What it does
36- /// Checks for calls to `std::mem::forget` with a reference
37- /// instead of an owned value.
38- ///
39- /// ### Why is this bad?
40- /// Calling `forget` on a reference will only forget the
41- /// reference itself, which is a no-op. It will not forget the underlying
42- /// referenced
43- /// value, which is likely what was intended.
44- ///
45- /// ### Example
46- /// ```rust
47- /// let x = Box::new(1);
48- /// std::mem::forget(&x) // Should have been forget(x), x will still be dropped
49- /// ```
50- [ clippy:: version = "pre 1.29.0" ]
51- pub FORGET_REF ,
52- correctness,
53- "calls to `std::mem::forget` with a reference instead of an owned value"
54- }
55-
56- declare_clippy_lint ! {
57- /// ### What it does
58- /// Checks for calls to `std::mem::drop` with a value
59- /// that derives the Copy trait
60- ///
61- /// ### Why is this bad?
62- /// Calling `std::mem::drop` [does nothing for types that
63- /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html), since the
64- /// value will be copied and moved into the function on invocation.
65- ///
66- /// ### Example
67- /// ```rust
68- /// let x: i32 = 42; // i32 implements Copy
69- /// std::mem::drop(x) // A copy of x is passed to the function, leaving the
70- /// // original unaffected
71- /// ```
72- [ clippy:: version = "pre 1.29.0" ]
73- pub DROP_COPY ,
74- correctness,
75- "calls to `std::mem::drop` with a value that implements Copy"
76- }
77-
78- declare_clippy_lint ! {
79- /// ### What it does
80- /// Checks for calls to `std::mem::forget` with a value that
81- /// derives the Copy trait
82- ///
83- /// ### Why is this bad?
84- /// Calling `std::mem::forget` [does nothing for types that
85- /// implement Copy](https://doc.rust-lang.org/std/mem/fn.drop.html) since the
86- /// value will be copied and moved into the function on invocation.
87- ///
88- /// An alternative, but also valid, explanation is that Copy types do not
89- /// implement
90- /// the Drop trait, which means they have no destructors. Without a destructor,
91- /// there
92- /// is nothing for `std::mem::forget` to ignore.
93- ///
94- /// ### Example
95- /// ```rust
96- /// let x: i32 = 42; // i32 implements Copy
97- /// std::mem::forget(x) // A copy of x is passed to the function, leaving the
98- /// // original unaffected
99- /// ```
100- [ clippy:: version = "pre 1.29.0" ]
101- pub FORGET_COPY ,
102- correctness,
103- "calls to `std::mem::forget` with a value that implements Copy"
104- }
105-
10610declare_clippy_lint ! {
10711 /// ### What it does
10812/// Checks for calls to `std::mem::drop` with a value that does not implement `Drop`.
@@ -172,24 +76,12 @@ declare_clippy_lint! {
17276 "use of safe `std::mem::drop` function to drop a std::mem::ManuallyDrop, which will not drop the inner value"
17377}
17478
175- const DROP_REF_SUMMARY : & str = "calls to `std::mem::drop` with a reference instead of an owned value. \
176- ;
177- const FORGET_REF_SUMMARY : & str = "calls to `std::mem::forget` with a reference instead of an owned value. \
178- ;
179- const DROP_COPY_SUMMARY : & str = "calls to `std::mem::drop` with a value that implements `Copy`. \
180- ;
181- const FORGET_COPY_SUMMARY : & str = "calls to `std::mem::forget` with a value that implements `Copy`. \
182- ;
18379const DROP_NON_DROP_SUMMARY : & str = "call to `std::mem::drop` with a value that does not implement `Drop`. \
18480;
18581const FORGET_NON_DROP_SUMMARY : & str = "call to `std::mem::forget` with a value that does not implement `Drop`. \
18682;
18783
18884declare_lint_pass ! ( DropForgetRef => [
189- DROP_REF ,
190- FORGET_REF ,
191- DROP_COPY ,
192- FORGET_COPY ,
19385 DROP_NON_DROP ,
19486 FORGET_NON_DROP ,
19587 UNDROPPED_MANUALLY_DROPS
@@ -206,10 +98,11 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
20698 let is_copy = is_copy ( cx, arg_ty) ;
20799 let drop_is_single_call_in_arm = is_single_call_in_arm ( cx, arg, expr) ;
208100 let ( lint, msg) = match fn_name {
209- sym:: mem_drop if arg_ty. is_ref ( ) && !drop_is_single_call_in_arm => ( DROP_REF , DROP_REF_SUMMARY ) ,
210- sym:: mem_forget if arg_ty. is_ref ( ) => ( FORGET_REF , FORGET_REF_SUMMARY ) ,
211- sym:: mem_drop if is_copy && !drop_is_single_call_in_arm => ( DROP_COPY , DROP_COPY_SUMMARY ) ,
212- sym:: mem_forget if is_copy => ( FORGET_COPY , FORGET_COPY_SUMMARY ) ,
101+ // early return for uplifted lints: drop_ref, drop_copy, forget_ref, forget_copy
102+ sym:: mem_drop if arg_ty. is_ref ( ) && !drop_is_single_call_in_arm => return ,
103+ sym:: mem_forget if arg_ty. is_ref ( ) => return ,
104+ sym:: mem_drop if is_copy && !drop_is_single_call_in_arm => return ,
105+ sym:: mem_forget if is_copy => return ,
213106 sym:: mem_drop if is_type_lang_item ( cx, arg_ty, LangItem :: ManuallyDrop ) => {
214107 span_lint_and_help (
215108 cx,
0 commit comments