Skip to content

Commit 4065223

Browse files
steffahnsteffahn
committed
Fix new pedantic clippy warnings
1 parent cfdb976 commit 4065223

File tree

5 files changed

+42
-38
lines changed

5 files changed

+42
-38
lines changed

‎src/external_trait_impls/rayon/helpers.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ use alloc::vec::Vec;
44
use rayon::iter::{IntoParallelIterator, ParallelIterator};
55

66
/// Helper for collecting parallel iterators to an intermediary
7+
#[allow(clippy::linkedlist)] // yes, we need linked list here for efficient appending!
78
pub(super) fn collect<I: IntoParallelIterator>(iter: I) -> (LinkedList<Vec<I::Item>>, usize) {
89
let list = iter
910
.into_par_iter()

‎src/external_trait_impls/rayon/map.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -512,7 +512,7 @@ mod test_par_map {
512512
where
513513
H: Hasher,
514514
{
515-
self.k.hash(state)
515+
self.k.hash(state);
516516
}
517517
}
518518

‎src/external_trait_impls/rayon/raw.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -134,7 +134,7 @@ impl<T: Send, A: Allocator + Clone> ParallelIterator for RawParDrain<'_, T, A> {
134134
C: UnindexedConsumer<Self::Item>,
135135
{
136136
let _guard = guard(self.table, |table| unsafe {
137-
table.as_mut().clear_no_drop()
137+
table.as_mut().clear_no_drop();
138138
});
139139
let iter = unsafe { self.table.as_ref().iter().iter };
140140
mem::forget(self);
@@ -146,7 +146,9 @@ impl<T: Send, A: Allocator + Clone> ParallelIterator for RawParDrain<'_, T, A> {
146146
impl<T, A: Allocator + Clone> Drop for RawParDrain<'_, T, A> {
147147
fn drop(&mut self) {
148148
// If drive_unindexed is not called then simply clear the table.
149-
unsafe { self.table.as_mut().clear() }
149+
unsafe {
150+
self.table.as_mut().clear();
151+
}
150152
}
151153
}
152154

‎src/external_trait_impls/serde.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -161,6 +161,7 @@ mod set {
161161
deserializer.deserialize_seq(visitor)
162162
}
163163

164+
#[allow(clippy::missing_errors_doc)]
164165
fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
165166
where
166167
D: Deserializer<'de>,

‎tests/rayon.rs

Lines changed: 35 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -269,20 +269,20 @@ fn map_seq_par_equivalence_existing_empty_extend_empty() {
269269
let mut map_seq = MAP_EXISTING_EMPTY.clone();
270270
let mut map_par = MAP_EXISTING_EMPTY.clone();
271271

272-
map_seq.extend(MAP_EXTENSION_EMPTY.iter().cloned());
273-
map_par.par_extend(MAP_EXTENSION_EMPTY.par_iter().cloned());
272+
map_seq.extend(MAP_EXTENSION_EMPTY.iter().copied());
273+
map_par.par_extend(MAP_EXTENSION_EMPTY.par_iter().copied());
274274

275275
assert_eq3!(map_seq, map_par, expected);
276276
}
277277

278278
#[test]
279279
fn map_seq_par_equivalence_existing_empty_extend() {
280-
let expected = MAP_EXTENSION.iter().cloned().collect::<HashMap<_, _>>();
280+
let expected = MAP_EXTENSION.iter().copied().collect::<HashMap<_, _>>();
281281
let mut map_seq = MAP_EXISTING_EMPTY.clone();
282282
let mut map_par = MAP_EXISTING_EMPTY.clone();
283283

284-
map_seq.extend(MAP_EXTENSION.iter().cloned());
285-
map_par.par_extend(MAP_EXTENSION.par_iter().cloned());
284+
map_seq.extend(MAP_EXTENSION.iter().copied());
285+
map_par.par_extend(MAP_EXTENSION.par_iter().copied());
286286

287287
assert_eq3!(map_seq, map_par, expected);
288288
}
@@ -293,8 +293,8 @@ fn map_seq_par_equivalence_existing_extend_empty() {
293293
let mut map_seq = MAP_EXISTING.clone();
294294
let mut map_par = MAP_EXISTING.clone();
295295

296-
map_seq.extend(MAP_EXTENSION_EMPTY.iter().cloned());
297-
map_par.par_extend(MAP_EXTENSION_EMPTY.par_iter().cloned());
296+
map_seq.extend(MAP_EXTENSION_EMPTY.iter().copied());
297+
map_par.par_extend(MAP_EXTENSION_EMPTY.par_iter().copied());
298298

299299
assert_eq3!(map_seq, map_par, expected);
300300
}
@@ -305,8 +305,8 @@ fn map_seq_par_equivalence_existing_extend() {
305305
let mut map_seq = MAP_EXISTING.clone();
306306
let mut map_par = MAP_EXISTING.clone();
307307

308-
map_seq.extend(MAP_EXTENSION.iter().cloned());
309-
map_par.par_extend(MAP_EXTENSION.par_iter().cloned());
308+
map_seq.extend(MAP_EXTENSION.iter().copied());
309+
map_par.par_extend(MAP_EXTENSION.par_iter().copied());
310310

311311
assert_eq3!(map_seq, map_par, expected);
312312
}
@@ -423,20 +423,20 @@ fn set_seq_par_equivalence_existing_empty_extend_empty() {
423423
let mut set_seq = SET_EXISTING_EMPTY.clone();
424424
let mut set_par = SET_EXISTING_EMPTY.clone();
425425

426-
set_seq.extend(SET_EXTENSION_EMPTY.iter().cloned());
427-
set_par.par_extend(SET_EXTENSION_EMPTY.par_iter().cloned());
426+
set_seq.extend(SET_EXTENSION_EMPTY.iter().copied());
427+
set_par.par_extend(SET_EXTENSION_EMPTY.par_iter().copied());
428428

429429
assert_eq3!(set_seq, set_par, expected);
430430
}
431431

432432
#[test]
433433
fn set_seq_par_equivalence_existing_empty_extend() {
434-
let expected = SET_EXTENSION.iter().cloned().collect::<HashSet<_>>();
434+
let expected = SET_EXTENSION.iter().copied().collect::<HashSet<_>>();
435435
let mut set_seq = SET_EXISTING_EMPTY.clone();
436436
let mut set_par = SET_EXISTING_EMPTY.clone();
437437

438-
set_seq.extend(SET_EXTENSION.iter().cloned());
439-
set_par.par_extend(SET_EXTENSION.par_iter().cloned());
438+
set_seq.extend(SET_EXTENSION.iter().copied());
439+
set_par.par_extend(SET_EXTENSION.par_iter().copied());
440440

441441
assert_eq3!(set_seq, set_par, expected);
442442
}
@@ -447,8 +447,8 @@ fn set_seq_par_equivalence_existing_extend_empty() {
447447
let mut set_seq = SET_EXISTING.clone();
448448
let mut set_par = SET_EXISTING.clone();
449449

450-
set_seq.extend(SET_EXTENSION_EMPTY.iter().cloned());
451-
set_par.par_extend(SET_EXTENSION_EMPTY.par_iter().cloned());
450+
set_seq.extend(SET_EXTENSION_EMPTY.iter().copied());
451+
set_par.par_extend(SET_EXTENSION_EMPTY.par_iter().copied());
452452

453453
assert_eq3!(set_seq, set_par, expected);
454454
}
@@ -459,37 +459,37 @@ fn set_seq_par_equivalence_existing_extend() {
459459
let mut set_seq = SET_EXISTING.clone();
460460
let mut set_par = SET_EXISTING.clone();
461461

462-
set_seq.extend(SET_EXTENSION.iter().cloned());
463-
set_par.par_extend(SET_EXTENSION.par_iter().cloned());
462+
set_seq.extend(SET_EXTENSION.iter().copied());
463+
set_par.par_extend(SET_EXTENSION.par_iter().copied());
464464

465465
assert_eq3!(set_seq, set_par, expected);
466466
}
467467

468468
lazy_static! {
469-
static ref SET_A: HashSet<char> = ['a', 'b', 'c', 'd'].iter().cloned().collect();
470-
static ref SET_B: HashSet<char> = ['a', 'b', 'e', 'f'].iter().cloned().collect();
471-
static ref SET_DIFF_AB: HashSet<char> = ['c', 'd'].iter().cloned().collect();
472-
static ref SET_DIFF_BA: HashSet<char> = ['e', 'f'].iter().cloned().collect();
473-
static ref SET_SYMM_DIFF_AB: HashSet<char> = ['c', 'd', 'e', 'f'].iter().cloned().collect();
474-
static ref SET_INTERSECTION_AB: HashSet<char> = ['a', 'b'].iter().cloned().collect();
469+
static ref SET_A: HashSet<char> = ['a', 'b', 'c', 'd'].iter().copied().collect();
470+
static ref SET_B: HashSet<char> = ['a', 'b', 'e', 'f'].iter().copied().collect();
471+
static ref SET_DIFF_AB: HashSet<char> = ['c', 'd'].iter().copied().collect();
472+
static ref SET_DIFF_BA: HashSet<char> = ['e', 'f'].iter().copied().collect();
473+
static ref SET_SYMM_DIFF_AB: HashSet<char> = ['c', 'd', 'e', 'f'].iter().copied().collect();
474+
static ref SET_INTERSECTION_AB: HashSet<char> = ['a', 'b'].iter().copied().collect();
475475
static ref SET_UNION_AB: HashSet<char> =
476-
['a', 'b', 'c', 'd', 'e', 'f'].iter().cloned().collect();
476+
['a', 'b', 'c', 'd', 'e', 'f'].iter().copied().collect();
477477
}
478478

479479
#[test]
480480
fn set_seq_par_equivalence_difference() {
481-
let diff_ab_seq = SET_A.difference(&*SET_B).cloned().collect::<HashSet<_>>();
481+
let diff_ab_seq = SET_A.difference(&*SET_B).copied().collect::<HashSet<_>>();
482482
let diff_ab_par = SET_A
483483
.par_difference(&*SET_B)
484-
.cloned()
484+
.copied()
485485
.collect::<HashSet<_>>();
486486

487487
assert_eq3!(diff_ab_seq, diff_ab_par, *SET_DIFF_AB);
488488

489-
let diff_ba_seq = SET_B.difference(&*SET_A).cloned().collect::<HashSet<_>>();
489+
let diff_ba_seq = SET_B.difference(&*SET_A).copied().collect::<HashSet<_>>();
490490
let diff_ba_par = SET_B
491491
.par_difference(&*SET_A)
492-
.cloned()
492+
.copied()
493493
.collect::<HashSet<_>>();
494494

495495
assert_eq3!(diff_ba_seq, diff_ba_par, *SET_DIFF_BA);
@@ -499,22 +499,22 @@ fn set_seq_par_equivalence_difference() {
499499
fn set_seq_par_equivalence_symmetric_difference() {
500500
let symm_diff_ab_seq = SET_A
501501
.symmetric_difference(&*SET_B)
502-
.cloned()
502+
.copied()
503503
.collect::<HashSet<_>>();
504504
let symm_diff_ab_par = SET_A
505505
.par_symmetric_difference(&*SET_B)
506-
.cloned()
506+
.copied()
507507
.collect::<HashSet<_>>();
508508

509509
assert_eq3!(symm_diff_ab_seq, symm_diff_ab_par, *SET_SYMM_DIFF_AB);
510510
}
511511

512512
#[test]
513513
fn set_seq_par_equivalence_intersection() {
514-
let intersection_ab_seq = SET_A.intersection(&*SET_B).cloned().collect::<HashSet<_>>();
514+
let intersection_ab_seq = SET_A.intersection(&*SET_B).copied().collect::<HashSet<_>>();
515515
let intersection_ab_par = SET_A
516516
.par_intersection(&*SET_B)
517-
.cloned()
517+
.copied()
518518
.collect::<HashSet<_>>();
519519

520520
assert_eq3!(
@@ -526,8 +526,8 @@ fn set_seq_par_equivalence_intersection() {
526526

527527
#[test]
528528
fn set_seq_par_equivalence_union() {
529-
let union_ab_seq = SET_A.union(&*SET_B).cloned().collect::<HashSet<_>>();
530-
let union_ab_par = SET_A.par_union(&*SET_B).cloned().collect::<HashSet<_>>();
529+
let union_ab_seq = SET_A.union(&*SET_B).copied().collect::<HashSet<_>>();
530+
let union_ab_par = SET_A.par_union(&*SET_B).copied().collect::<HashSet<_>>();
531531

532532
assert_eq3!(union_ab_seq, union_ab_par, *SET_UNION_AB);
533533
}

0 commit comments

Comments
 (0)