src/tools/clippy/tests/ui/question_mark.fixed

   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     a?;
   8
   9     a
  10 }
  11
  12 fn 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
  21 pub enum SeemsOption<T> {
  22     Some(T),
  23     None,
  24 }
  25
  26 impl<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
  35 fn 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
  43 pub struct CopyStruct {
  44     pub opt: Option<u32>,
  45 }
  46
  47 impl 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)]
  63 pub struct MoveStruct {
  64     pub opt: Option<Vec<u32>>,
  65 }
  66
  67 impl 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
  98 fn func() -> Option<i32> {
  99     fn f() -> Option<String> {
 100         Some(String::new())
 101     }
 102
 103     f()?;
 104
 105     Some(0)
 106 }
 107
 108 fn func_returning_result() -> Result<i32, i32> {
 109     Ok(1)
 110 }
 111
 112 fn 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     Ok(y)
 138 }
 139
 140 // see issue #8019
 141 pub enum NotOption {
 142     None,
 143     First,
 144     AfterFirst,
 145 }
 146
 147 fn obj(_: i32) -> Result<(), NotOption> {
 148     Err(NotOption::First)
 149 }
 150
 151 fn f() -> NotOption {
 152     if obj(2).is_err() {
 153         return NotOption::None;
 154     }
 155     NotOption::First
 156 }
 157
 158 fn do_something() {}
 159
 160 fn err_immediate_return() -> Result<i32, i32> {
 161     func_returning_result()?;
 162     Ok(1)
 163 }
 164
 165 fn err_immediate_return_and_do_something() -> Result<i32, i32> {
 166     func_returning_result()?;
 167     do_something();
 168     Ok(1)
 169 }
 170
 171 // No warning
 172 fn no_immediate_return() -> Result<i32, i32> {
 173     if let Err(err) = func_returning_result() {
 174         do_something();
 175         return Err(err);
 176     }
 177     Ok(1)
 178 }
 179
 180 // No warning
 181 fn mixed_result_and_option() -> Option<i32> {
 182     if let Err(err) = func_returning_result() {
 183         return Some(err);
 184     }
 185     None
 186 }
 187
 188 // No warning
 189 fn else_if_check() -> Result<i32, i32> {
 190     if true {
 191         Ok(1)
 192     } else if let Err(e) = func_returning_result() {
 193         Err(e)
 194     } else {
 195         Err(-1)
 196     }
 197 }
 198
 199 // No warning
 200 #[allow(clippy::manual_map)]
 201 #[rustfmt::skip]
 202 fn option_map() -> Option<bool> {
 203     if let Some(a) = Some(false) {
 204         Some(!a)
 205     } else {
 206         None
 207     }
 208 }
 209
 210 pub struct PatternedError {
 211     flag: bool,
 212 }
 213
 214 // No warning
 215 fn pattern() -> Result<(), PatternedError> {
 216     let res = Ok(());
 217
 218     if let Err(err @ PatternedError { flag: true }) = res {
 219         return Err(err);
 220     }
 221
 222     res
 223 }
 224
 225 fn main() {}