add test from lintcheck

Author: ada4a

tests/ui/significant_drop_tightening.fixed

@@ -1,4 +1,5 @@
-#![warn(clippy::significant_drop_tightening)]
+
+drop(inner);#![warn(clippy::significant_drop_tightening)]
 
 use std::sync::Mutex;
 
@@ -142,6 +143,48 @@ pub fn unnecessary_contention_with_single_owned_results() {
     }
 }
 
+fn issue_15574() {
+    mod lintcheck1 {
+        struct Inner<T> {
+            is_disconnected: bool,
+            receivers: Receivers<T>,
+        }
+
+        struct Receivers<T>(Vec<T>);
+
+        impl<T> Receivers<T> {
+            fn try_select(&mut self) -> Option<T> {
+                todo!()
+            }
+        }
+
+        struct Operation {
+            packet: *mut (),
+        }
+
+        struct Token {
+            zero: Zero,
+        }
+        struct Zero(*mut ());
+
+        fn start_send(inner: &std::sync::Mutex<Inner<Operation>>, token: &mut Token) -> bool {
+            let mut inner = inner.lock().unwrap();
+            //~^ significant_drop_tightening
+
+            // If there's a waiting receiver, pair up with it.
+            if let Some(operation) = inner.receivers.try_select() {
+                token.zero.0 = operation.packet;
+                true
+            } else if inner.is_disconnected {
+                token.zero.0 = std::ptr::null_mut();
+                true
+            } else {
+                false
+            }
+        }
+    }
+}
+
 // Marker used for illustration purposes.
 pub fn do_heavy_computation_that_takes_time<T>(_: T) {}
 

tests/ui/significant_drop_tightening.rs

@@ -138,6 +138,48 @@ pub fn unnecessary_contention_with_single_owned_results() {
     }
 }
 
+fn issue_15574() {
+    mod lintcheck1 {
+        struct Inner<T> {
+            is_disconnected: bool,
+            receivers: Receivers<T>,
+        }
+
+        struct Receivers<T>(Vec<T>);
+
+        impl<T> Receivers<T> {
+            fn try_select(&mut self) -> Option<T> {
+                todo!()
+            }
+        }
+
+        struct Operation {
+            packet: *mut (),
+        }
+
+        struct Token {
+            zero: Zero,
+        }
+        struct Zero(*mut ());
+
+        fn start_send(inner: &std::sync::Mutex<Inner<Operation>>, token: &mut Token) -> bool {
+            let mut inner = inner.lock().unwrap();
+            //~^ significant_drop_tightening
+
+            // If there's a waiting receiver, pair up with it.
+            if let Some(operation) = inner.receivers.try_select() {
+                token.zero.0 = operation.packet;
+                true
+            } else if inner.is_disconnected {
+                token.zero.0 = std::ptr::null_mut();
+                true
+            } else {
+                false
+            }
+        }
+    }
+}
+
 // Marker used for illustration purposes.
 pub fn do_heavy_computation_that_takes_time<T>(_: T) {}
 

tests/ui/significant_drop_tightening.stderr

@@ -83,5 +83,24 @@ LL |
 LL ~         
    |
 
-error: aborting due to 4 previous errors
+error: temporary with significant `Drop` can be early dropped
+  --> tests/ui/significant_drop_tightening.rs:166:21
+   |
+LL |           fn start_send(inner: &std::sync::Mutex<Inner<Operation>>, token: &mut Token) -> bool {
+   |  ______________________________________________________________________________________________-
+LL | |             let mut inner = inner.lock().unwrap();
+   | |                     ^^^^^
+...  |
+LL | |         }
+   | |_________- temporary `inner` is currently being dropped at the end of its contained scope
+   |
+   = note: this might lead to unnecessary resource contention
+help: drop the temporary after the end of its last usage
+  --> /home/ada4a/dev/minor/clippy/tests/clippy.toml:1:1
+   |
+LL + 
+LL ~ drop(inner);# default config for tests, overrides clippy.toml at the project root
+   |
+
+error: aborting due to 5 previous errors