fork/rust

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

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

master
4.6 KiB275 linesraw
1#![feature(try_blocks)]
2#![allow(unreachable_code)]
3#![allow(dead_code)]
4#![allow(clippy::unnecessary_wraps)]
5
6fn some_func(a: Option<u32>) -> Option<u32> {
7    a?;
8
9    a
10}
11
12fn some_other_func(a: Option<u32>) -> Option<u32> {
13    if a.is_none() {
14        return None;
15    } else {
16        return Some(0);
17    }
18    unreachable!()
19}
20
21pub enum SeemsOption<T> {
22    Some(T),
23    None,
24}
25
26impl<T> SeemsOption<T> {
27    pub fn is_none(&self) -> bool {
28        match *self {
29            SeemsOption::None => true,
30            SeemsOption::Some(_) => false,
31        }
32    }
33}
34
35fn returns_something_similar_to_option(a: SeemsOption<u32>) -> SeemsOption<u32> {
36    if a.is_none() {
37        return SeemsOption::None;
38    }
39
40    a
41}
42
43pub struct CopyStruct {
44    pub opt: Option<u32>,
45}
46
47impl CopyStruct {
48    #[rustfmt::skip]
49    pub fn func(&self) -> Option<u32> {
50        (self.opt)?;
51
52        self.opt?;
53
54        let _ = Some(self.opt?);
55
56        let _ = self.opt?;
57
58        self.opt
59    }
60}
61
62#[derive(Clone)]
63pub struct MoveStruct {
64    pub opt: Option<Vec<u32>>,
65}
66
67impl MoveStruct {
68    pub fn ref_func(&self) -> Option<Vec<u32>> {
69        self.opt.as_ref()?;
70
71        self.opt.clone()
72    }
73
74    pub fn mov_func_reuse(self) -> Option<Vec<u32>> {
75        self.opt.as_ref()?;
76
77        self.opt
78    }
79
80    pub fn mov_func_no_use(self) -> Option<Vec<u32>> {
81        self.opt.as_ref()?;
82        Some(Vec::new())
83    }
84
85    pub fn if_let_ref_func(self) -> Option<Vec<u32>> {
86        let v: &Vec<_> = self.opt.as_ref()?;
87
88        Some(v.clone())
89    }
90
91    pub fn if_let_mov_func(self) -> Option<Vec<u32>> {
92        let v = self.opt?;
93
94        Some(v)
95    }
96}
97
98fn func() -> Option<i32> {
99    fn f() -> Option<String> {
100        Some(String::new())
101    }
102
103    f()?;
104
105    Some(0)
106}
107
108fn func_returning_result() -> Result<i32, i32> {
109    Ok(1)
110}
111
112fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
113    let _ = x?;
114
115    x?;
116
117    // No warning
118    let y = if let Ok(x) = x {
119        x
120    } else {
121        return Err(0);
122    };
123
124    // issue #7859
125    // no warning
126    let _ = if let Ok(x) = func_returning_result() {
127        x
128    } else {
129        return Err(0);
130    };
131
132    // no warning
133    if func_returning_result().is_err() {
134        return func_returning_result();
135    }
136
137    // no warning
138    let _ = if let Err(e) = x { Err(e) } else { Ok(0) };
139
140    // issue #11283
141    // no warning
142    #[warn(clippy::question_mark_used)]
143    {
144        if let Err(err) = Ok(()) {
145            return Err(err);
146        }
147
148        if Err::<i32, _>(0).is_err() {
149            return Err(0);
150        } else {
151            return Ok(0);
152        }
153
154        unreachable!()
155    }
156
157    Ok(y)
158}
159
160// see issue #8019
161pub enum NotOption {
162    None,
163    First,
164    AfterFirst,
165}
166
167fn obj(_: i32) -> Result<(), NotOption> {
168    Err(NotOption::First)
169}
170
171fn f() -> NotOption {
172    if obj(2).is_err() {
173        return NotOption::None;
174    }
175    NotOption::First
176}
177
178fn do_something() {}
179
180fn err_immediate_return() -> Result<i32, i32> {
181    func_returning_result()?;
182    Ok(1)
183}
184
185fn err_immediate_return_and_do_something() -> Result<i32, i32> {
186    func_returning_result()?;
187    do_something();
188    Ok(1)
189}
190
191// No warning
192fn no_immediate_return() -> Result<i32, i32> {
193    if let Err(err) = func_returning_result() {
194        do_something();
195        return Err(err);
196    }
197    Ok(1)
198}
199
200// No warning
201fn mixed_result_and_option() -> Option<i32> {
202    if let Err(err) = func_returning_result() {
203        return Some(err);
204    }
205    None
206}
207
208// No warning
209fn else_if_check() -> Result<i32, i32> {
210    if true {
211        Ok(1)
212    } else if let Err(e) = func_returning_result() {
213        Err(e)
214    } else {
215        Err(-1)
216    }
217}
218
219// No warning
220#[allow(clippy::manual_map)]
221#[rustfmt::skip]
222fn option_map() -> Option<bool> {
223    if let Some(a) = Some(false) {
224        Some(!a)
225    } else {
226        None
227    }
228}
229
230pub struct PatternedError {
231    flag: bool,
232}
233
234// No warning
235fn pattern() -> Result<(), PatternedError> {
236    let res = Ok(());
237
238    if let Err(err @ PatternedError { flag: true }) = res {
239        return Err(err);
240    }
241
242    res
243}
244
245fn main() {}
246
247// `?` is not the same as `return None;` if inside of a try block
248fn issue8628(a: Option<u32>) -> Option<u32> {
249    let b: Option<u32> = try {
250        if a.is_none() {
251            return None;
252        }
253        32
254    };
255    b.or(Some(128))
256}
257
258fn issue6828_nested_body() -> Option<u32> {
259    try {
260        fn f2(a: Option<i32>) -> Option<i32> {
261            a?;
262            Some(32)
263        }
264        123
265    }
266}
267
268// should not lint, `?` operator not available in const context
269const fn issue9175(option: Option<()>) -> Option<()> {
270    if option.is_none() {
271        return None;
272    }
273    //stuff
274    Some(())
275}