src/tools/clippy/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     Ok(y)
 170 }
 171
 172 // see issue #8019
 173 pub enum NotOption {
 174     None,
 175     First,
 176     AfterFirst,
 177 }
 178
 179 fn obj(_: i32) -> Result<(), NotOption> {
 180     Err(NotOption::First)
 181 }
 182
 183 fn f() -> NotOption {
 184     if obj(2).is_err() {
 185         return NotOption::None;
 186     }
 187     NotOption::First
 188 }
 189
 190 fn do_something() {}
 191
 192 fn err_immediate_return() -> Result<i32, i32> {
 193     if let Err(err) = func_returning_result() {
 194         return Err(err);
 195     }
 196     Ok(1)
 197 }
 198
 199 fn err_immediate_return_and_do_something() -> Result<i32, i32> {
 200     if let Err(err) = func_returning_result() {
 201         return Err(err);
 202     }
 203     do_something();
 204     Ok(1)
 205 }
 206
 207 // No warning
 208 fn no_immediate_return() -> Result<i32, i32> {
 209     if let Err(err) = func_returning_result() {
 210         do_something();
 211         return Err(err);
 212     }
 213     Ok(1)
 214 }
 215
 216 // No warning
 217 fn mixed_result_and_option() -> Option<i32> {
 218     if let Err(err) = func_returning_result() {
 219         return Some(err);
 220     }
 221     None
 222 }
 223
 224 // No warning
 225 fn else_if_check() -> Result<i32, i32> {
 226     if true {
 227         Ok(1)
 228     } else if let Err(e) = func_returning_result() {
 229         Err(e)
 230     } else {
 231         Err(-1)
 232     }
 233 }
 234
 235 // No warning
 236 #[allow(clippy::manual_map)]
 237 #[rustfmt::skip]
 238 fn option_map() -> Option<bool> {
 239     if let Some(a) = Some(false) {
 240         Some(!a)
 241     } else {
 242         None
 243     }
 244 }
 245
 246 pub struct PatternedError {
 247     flag: bool,
 248 }
 249
 250 // No warning
 251 fn pattern() -> Result<(), PatternedError> {
 252     let res = Ok(());
 253
 254     if let Err(err @ PatternedError { flag: true }) = res {
 255         return Err(err);
 256     }
 257
 258     res
 259 }
 260
 261 fn main() {}
 262
 263 // should not lint, `?` operator not available in const context
 264 const fn issue9175(option: Option<()>) -> Option<()> {
 265     if option.is_none() {
 266         return None;
 267     }
 268     //stuff
 269     Some(())
 270 }