tests/ui/or_fun_call.rs

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