fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
3.4 KiB144 linesraw
1#![warn(clippy::significant_drop_tightening)]
2
3use std::sync::Mutex;
4
5pub fn complex_return_triggers_the_lint() -> i32 {
6    fn foo() -> i32 {
7        1
8    }
9    let mutex = Mutex::new(1);
10    let lock = mutex.lock().unwrap();
11    let _ = *lock;
12    let _ = *lock;
13    drop(lock);
14    foo()
15}
16
17pub fn issue_10413() {
18    let mutex = Mutex::new(Some(1));
19    let opt = Some(1);
20    if opt.is_some() {
21        let lock = mutex.lock().unwrap();
22        let _ = *lock;
23        if opt.is_some() {
24            let _ = *lock;
25        }
26    }
27}
28
29pub fn issue_11128() {
30    use std::mem::drop as unlock;
31
32    struct Foo {
33        droppable: Option<Vec<i32>>,
34        mutex: Mutex<Vec<i32>>,
35    }
36
37    impl Drop for Foo {
38        fn drop(&mut self) {
39            if let Some(droppable) = self.droppable.take() {
40                let lock = self.mutex.lock().unwrap();
41                let idx_opt = lock.iter().copied().find(|el| Some(el) == droppable.first());
42                if let Some(idx) = idx_opt {
43                    let local_droppable = vec![lock.first().copied().unwrap_or_default()];
44                    unlock(lock);
45                    drop(local_droppable);
46                }
47            }
48        }
49    }
50}
51
52pub fn issue_11160() -> bool {
53    let mutex = Mutex::new(1i32);
54    let lock = mutex.lock().unwrap();
55    let _ = lock.abs();
56    true
57}
58
59pub fn issue_11189() {
60    struct Number {
61        pub value: u32,
62    }
63
64    fn do_something() -> Result<(), ()> {
65        let number = Mutex::new(Number { value: 1 });
66        let number2 = Mutex::new(Number { value: 2 });
67        let number3 = Mutex::new(Number { value: 3 });
68        let mut lock = number.lock().unwrap();
69        let mut lock2 = number2.lock().unwrap();
70        let mut lock3 = number3.lock().unwrap();
71        lock.value += 1;
72        lock2.value += 1;
73        lock3.value += 1;
74        drop((lock, lock2, lock3));
75        Ok(())
76    }
77}
78
79pub fn path_return_can_be_ignored() -> i32 {
80    let mutex = Mutex::new(1);
81    let lock = mutex.lock().unwrap();
82    let rslt = *lock;
83    let _ = *lock;
84    rslt
85}
86
87pub fn post_bindings_can_be_ignored() {
88    let mutex = Mutex::new(1);
89    let lock = mutex.lock().unwrap();
90    let rslt = *lock;
91    let another = rslt;
92    let _ = another;
93}
94
95pub fn unnecessary_contention_with_multiple_owned_results() {
96    {
97        let mutex = Mutex::new(1i32);
98        let lock = mutex.lock().unwrap();
99        let _ = lock.abs();
100        let _ = lock.is_positive();
101    }
102
103    {
104        let mutex = Mutex::new(1i32);
105        let lock = mutex.lock().unwrap();
106        let rslt0 = lock.abs();
107        let rslt1 = lock.is_positive();
108        drop(lock);
109        do_heavy_computation_that_takes_time((rslt0, rslt1));
110    }
111}
112
113pub fn unnecessary_contention_with_single_owned_results() {
114    {
115        let mutex = Mutex::new(1i32);
116        let lock = mutex.lock().unwrap();
117        let _ = lock.abs();
118    }
119    {
120        let mutex = Mutex::new(vec![1i32]);
121        let mut lock = mutex.lock().unwrap();
122        lock.clear();
123    }
124
125    {
126        let mutex = Mutex::new(1i32);
127        
128        let rslt0 = mutex.lock().unwrap().abs();
129        
130        do_heavy_computation_that_takes_time(rslt0);
131    }
132    {
133        let mutex = Mutex::new(vec![1i32]);
134        
135        mutex.lock().unwrap().clear();
136        
137        do_heavy_computation_that_takes_time(());
138    }
139}
140
141// Marker used for illustration purposes.
142pub fn do_heavy_computation_that_takes_time<T>(_: T) {}
143
144fn main() {}