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

   1 // run-rustfix
   2
   3 #![warn(clippy::or_fun_call)]
   4 #![allow(dead_code)]
   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     enum Enum {
  21         A(i32),
  22     }
  23
  24     fn make<T>() -> T {
  25         unimplemented!();
  26     }
  27
  28     let with_enum = Some(Enum::A(1));
  29     with_enum.unwrap_or(Enum::A(5));
  30
  31     let with_const_fn = Some(Duration::from_secs(1));
  32     with_const_fn.unwrap_or_else(|| Duration::from_secs(5));
  33
  34     let with_constructor = Some(vec![1]);
  35     with_constructor.unwrap_or_else(make);
  36
  37     let with_new = Some(vec![1]);
  38     with_new.unwrap_or_default();
  39
  40     let with_const_args = Some(vec![1]);
  41     with_const_args.unwrap_or_else(|| Vec::with_capacity(12));
  42
  43     let with_err: Result<_, ()> = Ok(vec![1]);
  44     with_err.unwrap_or_else(|_| make());
  45
  46     let with_err_args: Result<_, ()> = Ok(vec![1]);
  47     with_err_args.unwrap_or_else(|_| Vec::with_capacity(12));
  48
  49     let with_default_trait = Some(1);
  50     with_default_trait.unwrap_or_default();
  51
  52     let with_default_type = Some(1);
  53     with_default_type.unwrap_or_default();
  54
  55     let with_vec = Some(vec![1]);
  56     with_vec.unwrap_or_default();
  57
  58     let without_default = Some(Foo);
  59     without_default.unwrap_or_else(Foo::new);
  60
  61     let stringy = Some(String::from(""));
  62     let _ = stringy.unwrap_or_else(|| "".to_owned());
  63
  64     let opt = Some(1);
  65     let hello = "Hello";
  66     let _ = opt.ok_or(format!("{} world.", hello));
  67 }
  68
  69 struct Foo(u8);
  70 struct Bar(String, Duration);
  71 #[rustfmt::skip]
  72 fn test_or_with_ctors() {
  73     let opt = Some(1);
  74     let opt_opt = Some(Some(1));
  75     // we also test for const promotion, this makes sure we don't hit that
  76     let two = 2;
  77
  78     let _ = opt_opt.unwrap_or(Some(2));
  79     let _ = opt_opt.unwrap_or(Some(two));
  80     let _ = opt.ok_or(Some(2));
  81     let _ = opt.ok_or(Some(two));
  82     let _ = opt.ok_or(Foo(2));
  83     let _ = opt.ok_or(Foo(two));
  84     let _ = opt.or(Some(2));
  85     let _ = opt.or(Some(two));
  86
  87     let _ = Some("a".to_string()).or_else(|| Some("b".to_string()));
  88
  89     let b = "b".to_string();
  90     let _ = Some(Bar("a".to_string(), Duration::from_secs(1)))
  91         .or_else(|| Some(Bar(b, Duration::from_secs(2))));
  92
  93     let vec = vec!["foo"];
  94     let _ = opt.ok_or(vec.len());
  95
  96     let array = ["foo"];
  97     let _ = opt.ok_or(array.len());
  98
  99     let slice = &["foo"][..];
 100     let _ = opt.ok_or(slice.len());
 101 }
 102
 103 // Issue 4514 - early return
 104 fn f() -> Option<()> {
 105     let a = Some(1);
 106     let b = 1i32;
 107
 108     let _ = a.unwrap_or(b.checked_mul(3)?.min(240));
 109
 110     Some(())
 111 }
 112
 113 // Issue 5886 - const fn (with no arguments)
 114 pub fn skip_const_fn_with_no_args() {
 115     const fn foo() -> Option<i32> {
 116         Some(42)
 117     }
 118     let _ = None.or(foo());
 119
 120     // See issue #5693.
 121     let mut map = std::collections::HashMap::new();
 122     map.insert(1, vec![1]);
 123     map.entry(1).or_insert(vec![]);
 124
 125     let mut map = HashMap::<u64, String>::new();
 126     map.entry(42).or_insert(String::new());
 127
 128     let mut btree = BTreeMap::<u64, String>::new();
 129     btree.entry(42).or_insert(String::new());
 130 }
 131
 132 fn main() {}