Skip to content

Commit be1ae29

Browse files
borsbors
committed
Auto merge of #288 - steffahn:clippy_more_features, r=Amanieu
Activate more features in clippy CI and fix new warnings ~~This PR is WIP,~~ the goal is to also fix the arising clippy warnings. Already opening a PR in order to test that the new CI command actually works.
2 parents e4ae53a + 4065223 commit be1ae29

File tree

6 files changed

+46
-42
lines changed

6 files changed

+46
-42
lines changed

‎ci/tools.sh‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ if retry rustup component add rustfmt ; then
3030
fi
3131

3232
if retry rustup component add clippy ; then
33-
cargo clippy --all --tests -- -D clippy::all -D clippy::pedantic
33+
cargo clippy --all --tests --features serde,rayon,bumpalo -- -D clippy::all -D clippy::pedantic
3434
fi
3535

3636
if command -v shellcheck ; then

‎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: 2 additions & 2 deletions
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

@@ -679,7 +679,7 @@ mod test_par_map {
679679
fn test_values_mut() {
680680
let vec = vec![(1, 1), (2, 2), (3, 3)];
681681
let mut map: HashMap<_, _> = vec.into_par_iter().collect();
682-
map.par_values_mut().for_each(|value| *value = (*value) * 2);
682+
map.par_values_mut().for_each(|value| *value *= 2);
683683
let values: Vec<_> = map.par_values().cloned().collect();
684684
assert_eq!(values.len(), 3);
685685
assert!(values.contains(&2));

‎src/external_trait_impls/rayon/raw.rs‎

Lines changed: 6 additions & 4 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

@@ -175,7 +177,7 @@ impl<T: Send> UnindexedProducer for ParDrainProducer<T> {
175177
{
176178
// Make sure to modify the iterator in-place so that any remaining
177179
// elements are processed in our Drop impl.
178-
while let Some(item) = self.iter.next() {
180+
for item in &mut self.iter {
179181
folder = folder.consume(unsafe { item.read() });
180182
if folder.full() {
181183
return folder;
@@ -193,7 +195,7 @@ impl<T> Drop for ParDrainProducer<T> {
193195
fn drop(&mut self) {
194196
// Drop all remaining elements
195197
if mem::needs_drop::<T>() {
196-
while let Some(item) = self.iter.next() {
198+
for item in &mut self.iter {
197199
unsafe {
198200
item.drop();
199201
}

‎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)