rust-clippy/tests/ui/unwrap_or_else_default.rs

163 lines
4.3 KiB
Rust

#![warn(clippy::unwrap_or_default)]
#![allow(dead_code)]
#![allow(clippy::unnecessary_wraps, clippy::unnecessary_literal_unwrap)]
/// Checks implementation of the `UNWRAP_OR_DEFAULT` lint.
fn unwrap_or_else_default() {
struct Foo;
impl Foo {
fn new() -> Foo {
Foo
}
// fake default, we should not trigger on this
fn default() -> Foo {
Foo
}
}
struct HasDefaultAndDuplicate;
impl HasDefaultAndDuplicate {
fn default() -> Self {
HasDefaultAndDuplicate
}
}
impl Default for HasDefaultAndDuplicate {
fn default() -> Self {
HasDefaultAndDuplicate
}
}
enum Enum {
A(),
}
fn make<T, V>(_: V) -> T {
unimplemented!();
}
let with_enum = Some(Enum::A());
with_enum.unwrap_or_else(Enum::A);
let with_new = Some(vec![1]);
with_new.unwrap_or_else(Vec::new);
let with_err: Result<_, ()> = Ok(vec![1]);
with_err.unwrap_or_else(make);
// should not be changed
let with_fake_default = None::<Foo>;
with_fake_default.unwrap_or_else(Foo::default);
// should not be changed
let with_fake_default2 = None::<HasDefaultAndDuplicate>;
with_fake_default2.unwrap_or_else(<HasDefaultAndDuplicate>::default);
let with_real_default = None::<HasDefaultAndDuplicate>;
with_real_default.unwrap_or_else(<HasDefaultAndDuplicate as Default>::default);
let with_default_trait = Some(1);
with_default_trait.unwrap_or_else(Default::default);
let with_default_type = Some(1);
with_default_type.unwrap_or_else(u64::default);
let with_default_type: Option<Vec<u64>> = None;
with_default_type.unwrap_or_else(Vec::new);
let empty_string = None::<String>;
empty_string.unwrap_or_else(|| "".to_string());
}
fn type_certainty(option: Option<Vec<u64>>) {
option.unwrap_or_else(Vec::new).push(1);
let option: std::option::Option<std::vec::Vec<u64>> = None;
option.unwrap_or_else(Vec::new).push(1);
let option: Option<Vec<u64>> = None;
option.unwrap_or_else(Vec::new).push(1);
let option = std::option::Option::<std::vec::Vec<u64>>::None;
option.unwrap_or_else(Vec::new).push(1);
let option = Option::<Vec<u64>>::None;
option.unwrap_or_else(Vec::new).push(1);
let option = std::option::Option::None::<std::vec::Vec<u64>>;
option.unwrap_or_else(Vec::new).push(1);
let option = Option::None::<Vec<u64>>;
option.unwrap_or_else(Vec::new).push(1);
let option = None::<Vec<u64>>;
option.unwrap_or_else(Vec::new).push(1);
// should not be changed: type annotation with infer, unconcretized initializer
let option: Option<Vec<_>> = None;
option.unwrap_or_else(Vec::new).push(1);
// should not be changed: no type annotation, unconcretized initializer
let option = Option::None;
option.unwrap_or_else(Vec::new).push(1);
// should not be changed: no type annotation, unconcretized initializer
let option = None;
option.unwrap_or_else(Vec::new).push(1);
type Alias = Option<Vec<u32>>;
let option: Alias = Option::<Vec<u32>>::Some(Vec::new());
option.unwrap_or_else(Vec::new).push(1);
}
fn method_call_with_deref() {
use std::cell::RefCell;
use std::collections::HashMap;
let cell = RefCell::new(HashMap::<u64, HashMap<u64, String>>::new());
let mut outer_map = cell.borrow_mut();
#[allow(unused_assignments)]
let mut option = None;
option = Some(0);
let inner_map = outer_map.get_mut(&option.unwrap()).unwrap();
let _ = inner_map.entry(0).or_insert_with(Default::default);
}
fn missing_suggested_method() {
#[derive(Copy, Clone)]
struct S<T>(T);
impl<T> S<T> {
fn or_insert_with(&mut self, default: impl FnOnce() -> T) -> &mut T {
&mut self.0
}
fn or_insert(&mut self, default: T) -> &mut T {
&mut self.0
}
fn unwrap_or_else(self, default: impl FnOnce() -> T) -> T {
self.0
}
fn unwrap_or(self, default: T) -> T {
self.0
}
}
// Don't lint when or_default/unwrap_or_default do not exist on the type
let mut s = S(1);
s.or_insert_with(Default::default);
s.or_insert(Default::default());
s.unwrap_or_else(Default::default);
s.unwrap_or(Default::default());
}
fn main() {}