]> git.lizzy.rs Git - rust.git/blob - tests/ui/question_mark.fixed
Auto merge of #8359 - flip1995:rustup, r=flip1995
[rust.git] / tests / ui / question_mark.fixed
1 // run-rustfix
2 #![allow(unreachable_code)]
3 #![allow(clippy::unnecessary_wraps)]
4
5 fn some_func(a: Option<u32>) -> Option<u32> {
6     a?;
7
8     a
9 }
10
11 fn some_other_func(a: Option<u32>) -> Option<u32> {
12     if a.is_none() {
13         return None;
14     } else {
15         return Some(0);
16     }
17     unreachable!()
18 }
19
20 pub enum SeemsOption<T> {
21     Some(T),
22     None,
23 }
24
25 impl<T> SeemsOption<T> {
26     pub fn is_none(&self) -> bool {
27         match *self {
28             SeemsOption::None => true,
29             SeemsOption::Some(_) => false,
30         }
31     }
32 }
33
34 fn returns_something_similar_to_option(a: SeemsOption<u32>) -> SeemsOption<u32> {
35     if a.is_none() {
36         return SeemsOption::None;
37     }
38
39     a
40 }
41
42 pub struct CopyStruct {
43     pub opt: Option<u32>,
44 }
45
46 impl CopyStruct {
47     #[rustfmt::skip]
48     pub fn func(&self) -> Option<u32> {
49         (self.opt)?;
50
51         self.opt?;
52
53         let _ = Some(self.opt?);
54
55         let _ = self.opt?;
56
57         self.opt
58     }
59 }
60
61 #[derive(Clone)]
62 pub struct MoveStruct {
63     pub opt: Option<Vec<u32>>,
64 }
65
66 impl MoveStruct {
67     pub fn ref_func(&self) -> Option<Vec<u32>> {
68         self.opt.as_ref()?;
69
70         self.opt.clone()
71     }
72
73     pub fn mov_func_reuse(self) -> Option<Vec<u32>> {
74         self.opt.as_ref()?;
75
76         self.opt
77     }
78
79     pub fn mov_func_no_use(self) -> Option<Vec<u32>> {
80         self.opt.as_ref()?;
81         Some(Vec::new())
82     }
83
84     pub fn if_let_ref_func(self) -> Option<Vec<u32>> {
85         let v: &Vec<_> = self.opt.as_ref()?;
86
87         Some(v.clone())
88     }
89
90     pub fn if_let_mov_func(self) -> Option<Vec<u32>> {
91         let v = self.opt?;
92
93         Some(v)
94     }
95 }
96
97 fn func() -> Option<i32> {
98     fn f() -> Option<String> {
99         Some(String::new())
100     }
101
102     f()?;
103
104     Some(0)
105 }
106
107 fn func_returning_result() -> Result<i32, i32> {
108     Ok(1)
109 }
110
111 fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
112     let _ = x?;
113
114     x?;
115
116     // No warning
117     let y = if let Ok(x) = x {
118         x
119     } else {
120         return Err(0);
121     };
122
123     // issue #7859
124     // no warning
125     let _ = if let Ok(x) = func_returning_result() {
126         x
127     } else {
128         return Err(0);
129     };
130
131     // no warning
132     if func_returning_result().is_err() {
133         return func_returning_result();
134     }
135
136     Ok(y)
137 }
138
139 // see issue #8019
140 pub enum NotOption {
141     None,
142     First,
143     AfterFirst,
144 }
145
146 fn obj(_: i32) -> Result<(), NotOption> {
147     Err(NotOption::First)
148 }
149
150 fn f() -> NotOption {
151     if obj(2).is_err() {
152         return NotOption::None;
153     }
154     NotOption::First
155 }
156
157 fn main() {
158     some_func(Some(42));
159     some_func(None);
160     some_other_func(Some(42));
161
162     let copy_struct = CopyStruct { opt: Some(54) };
163     copy_struct.func();
164
165     let move_struct = MoveStruct {
166         opt: Some(vec![42, 1337]),
167     };
168     move_struct.ref_func();
169     move_struct.clone().mov_func_reuse();
170     move_struct.mov_func_no_use();
171
172     let so = SeemsOption::Some(45);
173     returns_something_similar_to_option(so);
174
175     func();
176
177     let _ = result_func(Ok(42));
178     let _ = f();
179 }