2 #![warn(clippy::or_fun_call)]
4 #![allow(clippy::borrow_as_ptr, clippy::uninlined_format_args, clippy::unnecessary_wraps)]
6 use std::collections::BTreeMap;
7 use std::collections::HashMap;
8 use std::time::Duration;
10 /// Checks implementation of the `OR_FUN_CALL` lint.
22 fn default() -> Self {
27 impl Default for FakeDefault {
28 fn default() -> Self {
41 let with_enum = Some(Enum::A(1));
42 with_enum.unwrap_or(Enum::A(5));
44 let with_const_fn = Some(Duration::from_secs(1));
45 with_const_fn.unwrap_or(Duration::from_secs(5));
47 let with_constructor = Some(vec![1]);
48 with_constructor.unwrap_or_else(make);
50 let with_new = Some(vec![1]);
51 with_new.unwrap_or_default();
53 let with_const_args = Some(vec![1]);
54 with_const_args.unwrap_or_else(|| Vec::with_capacity(12));
56 let with_err: Result<_, ()> = Ok(vec![1]);
57 with_err.unwrap_or_else(|_| make());
59 let with_err_args: Result<_, ()> = Ok(vec![1]);
60 with_err_args.unwrap_or_else(|_| Vec::with_capacity(12));
62 let with_default_trait = Some(1);
63 with_default_trait.unwrap_or_default();
65 let with_default_type = Some(1);
66 with_default_type.unwrap_or_default();
68 let self_default = None::<FakeDefault>;
69 self_default.unwrap_or_else(<FakeDefault>::default);
71 let real_default = None::<FakeDefault>;
72 real_default.unwrap_or_default();
74 let with_vec = Some(vec![1]);
75 with_vec.unwrap_or_default();
77 let without_default = Some(Foo);
78 without_default.unwrap_or_else(Foo::new);
80 let mut map = HashMap::<u64, String>::new();
81 map.entry(42).or_default();
83 let mut map_vec = HashMap::<u64, Vec<i32>>::new();
84 map_vec.entry(42).or_default();
86 let mut btree = BTreeMap::<u64, String>::new();
87 btree.entry(42).or_default();
89 let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
90 btree_vec.entry(42).or_default();
92 let stringy = Some(String::new());
93 let _ = stringy.unwrap_or_default();
97 let _ = opt.ok_or(format!("{} world.", hello));
100 let map = HashMap::<u64, u64>::new();
101 let _ = Some(1).unwrap_or_else(|| map[&1]);
102 let map = BTreeMap::<u64, u64>::new();
103 let _ = Some(1).unwrap_or_else(|| map[&1]);
104 // don't lint index vec
106 let _ = Some(1).unwrap_or(vec[1]);
110 struct Bar(String, Duration);
112 fn test_or_with_ctors() {
114 let opt_opt = Some(Some(1));
115 // we also test for const promotion, this makes sure we don't hit that
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));
127 let _ = Some("a".to_string()).or_else(|| Some("b".to_string()));
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))));
133 let vec = vec!["foo"];
134 let _ = opt.ok_or(vec.len());
137 let _ = opt.ok_or(array.len());
139 let slice = &["foo"][..];
140 let _ = opt.ok_or(slice.len());
143 let _ = opt.ok_or(string.len());
146 // Issue 4514 - early return
147 fn f() -> Option<()> {
151 let _ = a.unwrap_or(b.checked_mul(3)?.min(240));
157 unsafe fn ptr_to_ref<'a, T>(p: *const T) -> &'a T {
159 let x = vec![0; 1000]; // future-proofing, make this function expensive.
164 let s = "test".to_owned();
165 let s = &s as *const _;
166 None.unwrap_or_else(|| ptr_to_ref(s));
170 let s = "test".to_owned();
171 let s = &s as *const _;
172 None.unwrap_or_else(|| unsafe { ptr_to_ref(s) });
174 None.unwrap_or_else(|| unsafe { ptr_to_ref(s) });
179 fn more_than_max_suggestion_highest_lines_0() {
180 let frames = Vec::new();
183 .map(|f: &String| f.to_lowercase())
184 .reduce(|mut acc, f| {
188 .unwrap_or_default();
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| {
201 .unwrap_or_default();
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| {
213 .unwrap_or_default();
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| {
224 .unwrap_or_default();