rust-clippy/tests/ui/or_fun_call.fixed

150 lines
3.7 KiB
Rust
Raw Normal View History

2019-08-22 05:41:00 +00:00
// run-rustfix
#![warn(clippy::or_fun_call)]
#![allow(dead_code)]
2020-11-17 16:01:22 +00:00
#![allow(clippy::unnecessary_wraps)]
2019-08-22 05:41:00 +00:00
use std::collections::BTreeMap;
use std::collections::HashMap;
use std::time::Duration;
/// Checks implementation of the `OR_FUN_CALL` lint.
fn or_fun_call() {
struct Foo;
impl Foo {
fn new() -> Foo {
Foo
}
}
enum Enum {
A(i32),
}
fn make<T>() -> T {
unimplemented!();
}
let with_enum = Some(Enum::A(1));
with_enum.unwrap_or(Enum::A(5));
let with_const_fn = Some(Duration::from_secs(1));
2020-06-07 01:07:48 +00:00
with_const_fn.unwrap_or_else(|| Duration::from_secs(5));
2019-08-22 05:41:00 +00:00
let with_constructor = Some(vec![1]);
with_constructor.unwrap_or_else(make);
let with_new = Some(vec![1]);
with_new.unwrap_or_default();
let with_const_args = Some(vec![1]);
with_const_args.unwrap_or_else(|| Vec::with_capacity(12));
let with_err: Result<_, ()> = Ok(vec![1]);
with_err.unwrap_or_else(|_| make());
let with_err_args: Result<_, ()> = Ok(vec![1]);
with_err_args.unwrap_or_else(|_| Vec::with_capacity(12));
let with_default_trait = Some(1);
with_default_trait.unwrap_or_default();
let with_default_type = Some(1);
with_default_type.unwrap_or_default();
let with_vec = Some(vec![1]);
2020-04-01 18:14:05 +00:00
with_vec.unwrap_or_default();
2019-08-22 05:41:00 +00:00
let without_default = Some(Foo);
without_default.unwrap_or_else(Foo::new);
let mut map = HashMap::<u64, String>::new();
map.entry(42).or_insert_with(String::new);
let mut map_vec = HashMap::<u64, Vec<i32>>::new();
map_vec.entry(42).or_insert_with(Vec::new);
let mut btree = BTreeMap::<u64, String>::new();
btree.entry(42).or_insert_with(String::new);
let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
btree_vec.entry(42).or_insert_with(Vec::new);
2019-08-22 05:41:00 +00:00
let stringy = Some(String::from(""));
let _ = stringy.unwrap_or_else(|| "".to_owned());
let opt = Some(1);
let hello = "Hello";
2019-11-25 12:56:24 +00:00
let _ = opt.ok_or(format!("{} world.", hello));
2020-10-29 20:30:20 +00:00
// index
let map = HashMap::<u64, u64>::new();
let _ = Some(1).unwrap_or_else(|| map[&1]);
let map = BTreeMap::<u64, u64>::new();
let _ = Some(1).unwrap_or_else(|| map[&1]);
// don't lint index vec
let vec = vec![1];
let _ = Some(1).unwrap_or(vec[1]);
2019-08-22 05:41:00 +00:00
}
struct Foo(u8);
struct Bar(String, Duration);
#[rustfmt::skip]
fn test_or_with_ctors() {
let opt = Some(1);
let opt_opt = Some(Some(1));
// we also test for const promotion, this makes sure we don't hit that
let two = 2;
let _ = opt_opt.unwrap_or(Some(2));
let _ = opt_opt.unwrap_or(Some(two));
let _ = opt.ok_or(Some(2));
let _ = opt.ok_or(Some(two));
let _ = opt.ok_or(Foo(2));
let _ = opt.ok_or(Foo(two));
let _ = opt.or(Some(2));
let _ = opt.or(Some(two));
let _ = Some("a".to_string()).or_else(|| Some("b".to_string()));
let b = "b".to_string();
let _ = Some(Bar("a".to_string(), Duration::from_secs(1)))
2020-06-07 01:07:48 +00:00
.or_else(|| Some(Bar(b, Duration::from_secs(2))));
let vec = vec!["foo"];
let _ = opt.ok_or(vec.len());
let array = ["foo"];
let _ = opt.ok_or(array.len());
let slice = &["foo"][..];
let _ = opt.ok_or(slice.len());
2019-08-22 05:41:00 +00:00
}
// Issue 4514 - early return
fn f() -> Option<()> {
let a = Some(1);
let b = 1i32;
let _ = a.unwrap_or(b.checked_mul(3)?.min(240));
Some(())
}
2021-03-17 19:29:31 +00:00
mod issue6675 {
unsafe fn foo() {
let mut s = "test".to_owned();
None.unwrap_or_else(|| s.as_mut_vec());
}
fn bar() {
let mut s = "test".to_owned();
None.unwrap_or_else(|| unsafe { s.as_mut_vec() });
#[rustfmt::skip]
None.unwrap_or_else(|| unsafe { s.as_mut_vec() });
}
}
2019-08-22 05:41:00 +00:00
fn main() {}