Auto merge of #252 - notriddle:notriddle/clippy-fixes, r=jdm

Clippy fixes

None

Author: bors-servo

src/atom.rs

@@ -10,7 +10,7 @@
 use crate::dynamic_set::{Entry, DYNAMIC_SET};
 use crate::static_sets::StaticAtomSet;
 use debug_unreachable::debug_unreachable;
-use phf_shared;
+
 use std::borrow::Cow;
 use std::cmp::Ordering::{self, Equal};
 use std::fmt;

src/dynamic_set.rs

@@ -56,7 +56,7 @@ impl Set {
             let mut ptr: Option<&mut Box<Entry>> = self.buckets[bucket_index].as_mut();
 
             while let Some(entry) = ptr.take() {
-                if entry.hash == hash && &*entry.string == &*string {
+                if entry.hash == hash && *entry.string == *string {
                     if entry.ref_count.fetch_add(1, SeqCst) > 0 {
                         return NonNull::from(&mut **entry);
                     }
@@ -94,11 +94,8 @@ impl Set {
 
         let mut current: &mut Option<Box<Entry>> = &mut self.buckets[bucket_index];
 
-        loop {
-            let entry_ptr: *mut Entry = match current.as_mut() {
-                Some(entry) => &mut **entry,
-                None => break,
-            };
+        while let Some(entry_ptr) = current.as_mut() {
+            let entry_ptr: *mut Entry = &mut **entry_ptr;
             if entry_ptr == ptr {
                 mem::drop(mem::replace(current, unsafe {
                     (*entry_ptr).next_in_bucket.take()

src/lib.rs

@@ -103,6 +103,19 @@
 
 #![cfg_attr(test, deny(warnings))]
 
+// Types, such as Atom, that impl Hash must follow the hash invariant: if two objects match
+// with PartialEq, they must also have the same Hash. Clippy warns on types that derive one while
+// manually impl-ing the other, because it seems easy for the two to drift apart, causing the
+// invariant to be violated.
+//
+// But Atom is a newtype over NonZeroU64, and probably always will be, since cheap comparisons and
+// copying are this library's purpose. So we know what the PartialEq comparison is going to do.
+//
+// The `get_hash` function, seen in `atom.rs`, consults that number, plus the global string interner
+// tables. The only way for the resulting hash for two Atoms with the same inner 64-bit number to
+// differ would be if the table entry changed between invocations, and that would be really bad.
+#![allow(clippy::derive_hash_xor_eq)]
+
 mod atom;
 mod dynamic_set;
 mod static_sets;

src/trivial_impls.rs

@@ -39,7 +39,7 @@ impl<Static: StaticAtomSet> PartialEq<Atom<Static>> for str {
 
 impl<Static: StaticAtomSet> PartialEq<String> for Atom<Static> {
     fn eq(&self, other: &String) -> bool {
-        &self[..] == &other[..]
+        self[..] == other[..]
     }
 }
 
@@ -66,7 +66,7 @@ impl<Static: StaticAtomSet> fmt::Display for Atom<Static> {
 
 impl<Static: StaticAtomSet> AsRef<str> for Atom<Static> {
     fn as_ref(&self) -> &str {
-        &self
+        self
     }
 }