src/tools/clippy/tests/ui/or_fun_call.rs

   1 // run-rustfix
   2 #![warn(clippy::or_fun_call)]
   3 #![allow(dead_code)]
   4 #![allow(clippy::borrow_as_ptr, clippy::uninlined_format_args, clippy::unnecessary_wraps)]
   5
   6 use std::collections::BTreeMap;
   7 use std::collections::HashMap;
   8 use std::time::Duration;
   9
  10 /// Checks implementation of the `OR_FUN_CALL` lint.
  11 fn or_fun_call() {
  12     struct Foo;
  13
  14     impl Foo {
  15         fn new() -> Foo {
  16             Foo
  17         }
  18     }
  19
  20     struct FakeDefault;
  21     impl FakeDefault {
  22         fn default() -> Self {
  23             FakeDefault
  24         }
  25     }
  26
  27     impl Default for FakeDefault {
  28         fn default() -> Self {
  29             FakeDefault
  30         }
  31     }
  32
  33     enum Enum {
  34         A(i32),
  35     }
  36
  37     fn make<T>() -> T {
  38         unimplemented!();
  39     }
  40
  41     let with_enum = Some(Enum::A(1));
  42     with_enum.unwrap_or(Enum::A(5));
  43
  44     let with_const_fn = Some(Duration::from_secs(1));
  45     with_const_fn.unwrap_or(Duration::from_secs(5));
  46
  47     let with_constructor = Some(vec![1]);
  48     with_constructor.unwrap_or(make());
  49
  50     let with_new = Some(vec![1]);
  51     with_new.unwrap_or(Vec::new());
  52
  53     let with_const_args = Some(vec![1]);
  54     with_const_args.unwrap_or(Vec::with_capacity(12));
  55
  56     let with_err: Result<_, ()> = Ok(vec![1]);
  57     with_err.unwrap_or(make());
  58
  59     let with_err_args: Result<_, ()> = Ok(vec![1]);
  60     with_err_args.unwrap_or(Vec::with_capacity(12));
  61
  62     let with_default_trait = Some(1);
  63     with_default_trait.unwrap_or(Default::default());
  64
  65     let with_default_type = Some(1);
  66     with_default_type.unwrap_or(u64::default());
  67
  68     let self_default = None::<FakeDefault>;
  69     self_default.unwrap_or(<FakeDefault>::default());
  70
  71     let real_default = None::<FakeDefault>;
  72     real_default.unwrap_or(<FakeDefault as Default>::default());
  73
  74     let with_vec = Some(vec![1]);
  75     with_vec.unwrap_or(vec![]);
  76
  77     let without_default = Some(Foo);
  78     without_default.unwrap_or(Foo::new());
  79
  80     let mut map = HashMap::<u64, String>::new();
  81     map.entry(42).or_insert(String::new());
  82
  83     let mut map_vec = HashMap::<u64, Vec<i32>>::new();
  84     map_vec.entry(42).or_insert(vec![]);
  85
  86     let mut btree = BTreeMap::<u64, String>::new();
  87     btree.entry(42).or_insert(String::new());
  88
  89     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
  90     btree_vec.entry(42).or_insert(vec![]);
  91
  92     let stringy = Some(String::new());
  93     let _ = stringy.unwrap_or(String::new());
  94
  95     let opt = Some(1);
  96     let hello = "Hello";
  97     let _ = opt.ok_or(format!("{} world.", hello));
  98
  99     // index
 100     let map = HashMap::<u64, u64>::new();
 101     let _ = Some(1).unwrap_or(map[&1]);
 102     let map = BTreeMap::<u64, u64>::new();
 103     let _ = Some(1).unwrap_or(map[&1]);
 104     // don't lint index vec
 105     let vec = vec![1];
 106     let _ = Some(1).unwrap_or(vec[1]);
 107 }
 108
 109 struct Foo(u8);
 110 struct Bar(String, Duration);
 111 #[rustfmt::skip]
 112 fn test_or_with_ctors() {
 113     let opt = Some(1);
 114     let opt_opt = Some(Some(1));
 115     // we also test for const promotion, this makes sure we don't hit that
 116     let two = 2;
 117
 118     let _ = opt_opt.unwrap_or(Some(2));
 119     let _ = opt_opt.unwrap_or(Some(two));
 120     let _ = opt.ok_or(Some(2));
 121     let _ = opt.ok_or(Some(two));
 122     let _ = opt.ok_or(Foo(2));
 123     let _ = opt.ok_or(Foo(two));
 124     let _ = opt.or(Some(2));
 125     let _ = opt.or(Some(two));
 126
 127     let _ = Some("a".to_string()).or(Some("b".to_string()));
 128
 129     let b = "b".to_string();
 130     let _ = Some(Bar("a".to_string(), Duration::from_secs(1)))
 131         .or(Some(Bar(b, Duration::from_secs(2))));
 132
 133     let vec = vec!["foo"];
 134     let _ = opt.ok_or(vec.len());
 135
 136     let array = ["foo"];
 137     let _ = opt.ok_or(array.len());
 138
 139     let slice = &["foo"][..];
 140     let _ = opt.ok_or(slice.len());
 141
 142     let string = "foo";
 143     let _ = opt.ok_or(string.len());
 144 }
 145
 146 // Issue 4514 - early return
 147 fn f() -> Option<()> {
 148     let a = Some(1);
 149     let b = 1i32;
 150
 151     let _ = a.unwrap_or(b.checked_mul(3)?.min(240));
 152
 153     Some(())
 154 }
 155
 156 mod issue6675 {
 157     unsafe fn ptr_to_ref<'a, T>(p: *const T) -> &'a T {
 158         #[allow(unused)]
 159         let x = vec![0; 1000]; // future-proofing, make this function expensive.
 160         &*p
 161     }
 162
 163     unsafe fn foo() {
 164         let s = "test".to_owned();
 165         let s = &s as *const _;
 166         None.unwrap_or(ptr_to_ref(s));
 167     }
 168
 169     fn bar() {
 170         let s = "test".to_owned();
 171         let s = &s as *const _;
 172         None.unwrap_or(unsafe { ptr_to_ref(s) });
 173         #[rustfmt::skip]
 174         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
 175     }
 176 }
 177
 178 mod issue8239 {
 179     fn more_than_max_suggestion_highest_lines_0() {
 180         let frames = Vec::new();
 181         frames
 182             .iter()
 183             .map(|f: &String| f.to_lowercase())
 184             .reduce(|mut acc, f| {
 185                 acc.push_str(&f);
 186                 acc
 187             })
 188             .unwrap_or(String::new());
 189     }
 190
 191     fn more_to_max_suggestion_highest_lines_1() {
 192         let frames = Vec::new();
 193         let iter = frames.iter();
 194         iter.map(|f: &String| f.to_lowercase())
 195             .reduce(|mut acc, f| {
 196                 let _ = "";
 197                 let _ = "";
 198                 acc.push_str(&f);
 199                 acc
 200             })
 201             .unwrap_or(String::new());
 202     }
 203
 204     fn equal_to_max_suggestion_highest_lines() {
 205         let frames = Vec::new();
 206         let iter = frames.iter();
 207         iter.map(|f: &String| f.to_lowercase())
 208             .reduce(|mut acc, f| {
 209                 let _ = "";
 210                 acc.push_str(&f);
 211                 acc
 212             })
 213             .unwrap_or(String::new());
 214     }
 215
 216     fn less_than_max_suggestion_highest_lines() {
 217         let frames = Vec::new();
 218         let iter = frames.iter();
 219         let map = iter.map(|f: &String| f.to_lowercase());
 220         map.reduce(|mut acc, f| {
 221             acc.push_str(&f);
 222             acc
 223         })
 224         .unwrap_or(String::new());
 225     }
 226 }
 227
 228 mod issue9608 {
 229     fn sig_drop() {
 230         enum X {
 231             X(std::fs::File),
 232             Y(u32),
 233         }
 234
 235         let _ = None.unwrap_or(X::Y(0));
 236     }
 237 }
 238
 239 fn main() {}