3 #![warn(clippy::or_fun_call)]
5 #![allow(clippy::unnecessary_wraps, clippy::borrow_as_ptr)]
7 use std::collections::BTreeMap;
8 use std::collections::HashMap;
9 use std::time::Duration;
11 /// Checks implementation of the `OR_FUN_CALL` lint.
23 fn default() -> Self {
28 impl Default for FakeDefault {
29 fn default() -> Self {
42 let with_enum = Some(Enum::A(1));
43 with_enum.unwrap_or(Enum::A(5));
45 let with_const_fn = Some(Duration::from_secs(1));
46 with_const_fn.unwrap_or(Duration::from_secs(5));
48 let with_constructor = Some(vec![1]);
49 with_constructor.unwrap_or(make());
51 let with_new = Some(vec![1]);
52 with_new.unwrap_or(Vec::new());
54 let with_const_args = Some(vec![1]);
55 with_const_args.unwrap_or(Vec::with_capacity(12));
57 let with_err: Result<_, ()> = Ok(vec![1]);
58 with_err.unwrap_or(make());
60 let with_err_args: Result<_, ()> = Ok(vec![1]);
61 with_err_args.unwrap_or(Vec::with_capacity(12));
63 let with_default_trait = Some(1);
64 with_default_trait.unwrap_or(Default::default());
66 let with_default_type = Some(1);
67 with_default_type.unwrap_or(u64::default());
69 let self_default = None::<FakeDefault>;
70 self_default.unwrap_or(<FakeDefault>::default());
72 let real_default = None::<FakeDefault>;
73 real_default.unwrap_or(<FakeDefault as Default>::default());
75 let with_vec = Some(vec![1]);
76 with_vec.unwrap_or(vec![]);
78 let without_default = Some(Foo);
79 without_default.unwrap_or(Foo::new());
81 let mut map = HashMap::<u64, String>::new();
82 map.entry(42).or_insert(String::new());
84 let mut map_vec = HashMap::<u64, Vec<i32>>::new();
85 map_vec.entry(42).or_insert(vec![]);
87 let mut btree = BTreeMap::<u64, String>::new();
88 btree.entry(42).or_insert(String::new());
90 let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
91 btree_vec.entry(42).or_insert(vec![]);
93 let stringy = Some(String::from(""));
94 let _ = stringy.unwrap_or("".to_owned());
98 let _ = opt.ok_or(format!("{} world.", hello));
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
107 let _ = Some(1).unwrap_or(vec[1]);
111 struct Bar(String, Duration);
113 fn test_or_with_ctors() {
115 let opt_opt = Some(Some(1));
116 // we also test for const promotion, this makes sure we don't hit that
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));
128 let _ = Some("a".to_string()).or(Some("b".to_string()));
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))));
134 let vec = vec!["foo"];
135 let _ = opt.ok_or(vec.len());
138 let _ = opt.ok_or(array.len());
140 let slice = &["foo"][..];
141 let _ = opt.ok_or(slice.len());
144 let _ = opt.ok_or(string.len());
147 // Issue 4514 - early return
148 fn f() -> Option<()> {
152 let _ = a.unwrap_or(b.checked_mul(3)?.min(240));
158 unsafe fn ptr_to_ref<'a, T>(p: *const T) -> &'a T {
160 let x = vec![0; 1000]; // future-proofing, make this function expensive.
165 let s = "test".to_owned();
166 let s = &s as *const _;
167 None.unwrap_or(ptr_to_ref(s));
171 let s = "test".to_owned();
172 let s = &s as *const _;
173 None.unwrap_or(unsafe { ptr_to_ref(s) });
175 None.unwrap_or( unsafe { ptr_to_ref(s) } );
180 fn more_than_max_suggestion_highest_lines_0() {
181 let frames = Vec::new();
184 .map(|f: &String| f.to_lowercase())
185 .reduce(|mut acc, f| {
189 .unwrap_or(String::new());
192 fn more_to_max_suggestion_highest_lines_1() {
193 let frames = Vec::new();
194 let iter = frames.iter();
195 iter.map(|f: &String| f.to_lowercase())
196 .reduce(|mut acc, f| {
202 .unwrap_or(String::new());
205 fn equal_to_max_suggestion_highest_lines() {
206 let frames = Vec::new();
207 let iter = frames.iter();
208 iter.map(|f: &String| f.to_lowercase())
209 .reduce(|mut acc, f| {
214 .unwrap_or(String::new());
217 fn less_than_max_suggestion_highest_lines() {
218 let frames = Vec::new();
219 let iter = frames.iter();
220 let map = iter.map(|f: &String| f.to_lowercase());
221 map.reduce(|mut acc, f| {
225 .unwrap_or(String::new());