tests/ui/question_mark.rs

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