fork/rust

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

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

master
5.9 KiB189 linesraw
1//@aux-build: proc_macros.rs
2#![warn(clippy::unnecessary_lazy_evaluations)]
3#![allow(clippy::redundant_closure)]
4#![allow(clippy::bind_instead_of_map)]
5#![allow(clippy::map_identity)]
6#![allow(clippy::needless_borrow)]
7#![allow(clippy::unnecessary_literal_unwrap)]
8
9use std::ops::Deref;
10
11extern crate proc_macros;
12use proc_macros::with_span;
13
14struct Deep(Option<usize>);
15
16#[derive(Copy, Clone)]
17struct SomeStruct {
18    some_field: usize,
19}
20
21impl SomeStruct {
22    fn return_some_field(&self) -> usize {
23        self.some_field
24    }
25}
26
27fn some_call<T: Default>() -> T {
28    T::default()
29}
30
31struct Issue9427(i32);
32
33impl Drop for Issue9427 {
34    fn drop(&mut self) {
35        println!("{}", self.0);
36    }
37}
38
39struct Issue9427FollowUp;
40
41impl Drop for Issue9427FollowUp {
42    fn drop(&mut self) {
43        panic!("side effect drop");
44    }
45}
46
47struct Issue10437;
48impl Deref for Issue10437 {
49    type Target = u32;
50    fn deref(&self) -> &Self::Target {
51        println!("side effect deref");
52        &0
53    }
54}
55
56fn main() {
57    let astronomers_pi = 10;
58    let ext_arr: [usize; 1] = [2];
59    let ext_str = SomeStruct { some_field: 10 };
60
61    let mut opt = Some(42);
62    let ext_opt = Some(42);
63    let nested_opt = Some(Some(42));
64    let nested_tuple_opt = Some(Some((42, 43)));
65    let cond = true;
66
67    // Should lint - Option
68    let _ = opt.unwrap_or(2);
69    let _ = opt.unwrap_or(astronomers_pi);
70    let _ = opt.unwrap_or(ext_str.some_field);
71    let _ = opt.unwrap_or_else(|| ext_arr[0]);
72    let _ = opt.and(ext_opt);
73    let _ = opt.or(ext_opt);
74    let _ = opt.or(None);
75    let _ = opt.get_or_insert(2);
76    let _ = opt.ok_or(2);
77    let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
78    let _ = cond.then_some(astronomers_pi);
79
80    // Should lint - Builtin deref
81    let r = &1;
82    let _ = Some(1).unwrap_or(*r);
83    let b = Box::new(1);
84    let _ = Some(1).unwrap_or(*b);
85    // Should lint - Builtin deref through autoderef
86    let _ = Some(1).as_ref().unwrap_or(&r);
87    let _ = Some(1).as_ref().unwrap_or(&b);
88
89    // Cases when unwrap is not called on a simple variable
90    let _ = Some(10).unwrap_or(2);
91    let _ = Some(10).and(ext_opt);
92    let _: Option<usize> = None.or(ext_opt);
93    let _ = None.get_or_insert(2);
94    let _: Result<usize, usize> = None.ok_or(2);
95    let _: Option<usize> = None.or(None);
96
97    let mut deep = Deep(Some(42));
98    let _ = deep.0.unwrap_or(2);
99    let _ = deep.0.and(ext_opt);
100    let _ = deep.0.or(None);
101    let _ = deep.0.get_or_insert(2);
102    let _ = deep.0.ok_or(2);
103
104    // Should not lint - Option
105    let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
106    let _ = nested_opt.unwrap_or_else(|| Some(some_call()));
107    let _ = nested_tuple_opt.unwrap_or_else(|| Some((some_call(), some_call())));
108    let _ = opt.or_else(some_call);
109    let _ = opt.or_else(|| some_call());
110    let _: Result<usize, usize> = opt.ok_or_else(|| some_call());
111    let _: Result<usize, usize> = opt.ok_or_else(some_call);
112    let _ = deep.0.get_or_insert_with(|| some_call());
113    let _ = deep.0.or_else(some_call);
114    let _ = deep.0.or_else(|| some_call());
115    let _ = opt.ok_or_else(|| ext_arr[0]);
116
117    let _ = Some(1).unwrap_or_else(|| *Issue10437); // Issue10437 has a deref impl
118    let _ = Some(1).unwrap_or(*Issue10437);
119
120    let _ = Some(1).as_ref().unwrap_or_else(|| &Issue10437);
121    let _ = Some(1).as_ref().unwrap_or(&Issue10437);
122
123    // Should not lint - bool
124    let _ = (0 == 1).then(|| Issue9427(0)); // Issue9427 has a significant drop
125    let _ = false.then(|| Issue9427FollowUp); // Issue9427FollowUp has a significant drop
126
127    // should not lint, bind_instead_of_map takes priority
128    let _ = Some(10).and_then(|idx| Some(ext_arr[idx]));
129    let _ = Some(10).and_then(|idx| Some(idx));
130
131    // should lint, bind_instead_of_map doesn't apply
132    let _: Option<usize> = None.or(Some(3));
133    let _ = deep.0.or(Some(3));
134    let _ = opt.or(Some(3));
135
136    // Should lint - Result
137    let res: Result<usize, usize> = Err(5);
138    let res2: Result<usize, SomeStruct> = Err(SomeStruct { some_field: 5 });
139
140    let _ = res2.unwrap_or(2);
141    let _ = res2.unwrap_or(astronomers_pi);
142    let _ = res2.unwrap_or(ext_str.some_field);
143
144    // Should not lint - Result
145    let _ = res.unwrap_or_else(|err| err);
146    let _ = res.unwrap_or_else(|err| ext_arr[err]);
147    let _ = res2.unwrap_or_else(|err| err.some_field);
148    let _ = res2.unwrap_or_else(|err| err.return_some_field());
149    let _ = res2.unwrap_or_else(|_| ext_str.return_some_field());
150
151    // should not lint, bind_instead_of_map takes priority
152    let _: Result<usize, usize> = res.and_then(|x| Ok(x));
153    let _: Result<usize, usize> = res.or_else(|err| Err(err));
154
155    let _: Result<usize, usize> = res.and_then(|_| Ok(2));
156    let _: Result<usize, usize> = res.and_then(|_| Ok(astronomers_pi));
157    let _: Result<usize, usize> = res.and_then(|_| Ok(ext_str.some_field));
158
159    let _: Result<usize, usize> = res.or_else(|_| Err(2));
160    let _: Result<usize, usize> = res.or_else(|_| Err(astronomers_pi));
161    let _: Result<usize, usize> = res.or_else(|_| Err(ext_str.some_field));
162
163    // should lint, bind_instead_of_map doesn't apply
164    let _: Result<usize, usize> = res.and(Err(2));
165    let _: Result<usize, usize> = res.and(Err(astronomers_pi));
166    let _: Result<usize, usize> = res.and(Err(ext_str.some_field));
167
168    let _: Result<usize, usize> = res.or(Ok(2));
169    let _: Result<usize, usize> = res.or(Ok(astronomers_pi));
170    let _: Result<usize, usize> = res.or(Ok(ext_str.some_field));
171    let _: Result<usize, usize> = res.
172    // some lines
173    // some lines
174    // some lines
175    // some lines
176    // some lines
177    // some lines
178    or(Ok(ext_str.some_field));
179
180    // neither bind_instead_of_map nor unnecessary_lazy_eval applies here
181    let _: Result<usize, usize> = res.and_then(|x| Err(x));
182    let _: Result<usize, usize> = res.or_else(|err| Ok(err));
183}
184
185#[allow(unused)]
186fn issue9485() {
187    // should not lint, is in proc macro
188    with_span!(span Some(42).unwrap_or_else(|| 2););
189}