Move trait impls that simply forward to something else to their own module

Author: SimonSapin

src/atom.rs

@@ -7,13 +7,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![allow(non_upper_case_globals)]
-
 use crate::dynamic_set::{Entry, DYNAMIC_SET};
 use crate::static_sets::StaticAtomSet;
 use debug_unreachable::debug_unreachable;
 use phf_shared;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::borrow::Cow;
 use std::cmp::Ordering::{self, Equal};
 use std::fmt;
@@ -85,18 +82,6 @@ pub struct Atom<Static> {
     phantom: PhantomData<Static>,
 }
 
-impl<Static: StaticAtomSet> ::precomputed_hash::PrecomputedHash for Atom<Static> {
-    fn precomputed_hash(&self) -> u32 {
-        self.get_hash()
-    }
-}
-
-impl<'a, Static: StaticAtomSet> From<&'a Atom<Static>> for Atom<Static> {
-    fn from(atom: &'a Self) -> Self {
-        atom.clone()
-    }
-}
-
 // FIXME: bound removed from the struct definition before of this error for pack_static:
 // "error[E0723]: trait bounds other than `Sized` on const fn parameters are unstable"
 // https://github.com/rust-lang/rust/issues/57563
@@ -183,24 +168,6 @@ impl<Static: StaticAtomSet> Hash for Atom<Static> {
     }
 }
 
-impl<Static: StaticAtomSet> PartialEq<str> for Atom<Static> {
-    fn eq(&self, other: &str) -> bool {
-        &self[..] == other
-    }
-}
-
-impl<Static: StaticAtomSet> PartialEq<Atom<Static>> for str {
-    fn eq(&self, other: &Atom<Static>) -> bool {
-        self == &other[..]
-    }
-}
-
-impl<Static: StaticAtomSet> PartialEq<String> for Atom<Static> {
-    fn eq(&self, other: &String) -> bool {
-        &self[..] == &other[..]
-    }
-}
-
 impl<'a, Static: StaticAtomSet> From<Cow<'a, str>> for Atom<Static> {
     fn from(string_to_add: Cow<'a, str>) -> Self {
         let static_set = Static::get();
@@ -237,20 +204,6 @@ impl<'a, Static: StaticAtomSet> From<Cow<'a, str>> for Atom<Static> {
     }
 }
 
-impl<'a, Static: StaticAtomSet> From<&'a str> for Atom<Static> {
-    #[inline]
-    fn from(string_to_add: &str) -> Self {
-        Atom::from(Cow::Borrowed(string_to_add))
-    }
-}
-
-impl<Static: StaticAtomSet> From<String> for Atom<Static> {
-    #[inline]
-    fn from(string_to_add: String) -> Self {
-        Atom::from(Cow::Owned(string_to_add))
-    }
-}
-
 impl<Static: StaticAtomSet> Clone for Atom<Static> {
     #[inline(always)]
     fn clone(&self) -> Self {
@@ -305,13 +258,6 @@ impl<Static: StaticAtomSet> ops::Deref for Atom<Static> {
     }
 }
 
-impl<Static: StaticAtomSet> fmt::Display for Atom<Static> {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        <str as fmt::Display>::fmt(self, f)
-    }
-}
-
 impl<Static: StaticAtomSet> fmt::Debug for Atom<Static> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -348,32 +294,6 @@ impl<Static: StaticAtomSet> Ord for Atom<Static> {
     }
 }
 
-impl<Static: StaticAtomSet> AsRef<str> for Atom<Static> {
-    fn as_ref(&self) -> &str {
-        &self
-    }
-}
-
-impl<Static: StaticAtomSet> Serialize for Atom<Static> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let string: &str = self.as_ref();
-        string.serialize(serializer)
-    }
-}
-
-impl<'a, Static: StaticAtomSet> Deserialize<'a> for Atom<Static> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'a>,
-    {
-        let string: String = Deserialize::deserialize(deserializer)?;
-        Ok(Atom::from(string))
-    }
-}
-
 // AsciiExt requires mutating methods, so we just implement the non-mutating ones.
 // We don't need to implement is_ascii because there's no performance improvement
 // over the one from &str.

src/lib.rs

@@ -106,6 +106,7 @@
 mod atom;
 mod dynamic_set;
 mod static_sets;
+mod trivial_impls;
 
 pub use atom::Atom;
 pub use static_sets::{EmptyStaticAtomSet, PhfStrSet, StaticAtomSet};

src/trivial_impls.rs

@@ -0,0 +1,90 @@
+// Copyright 2014 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::{Atom, StaticAtomSet};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::borrow::Cow;
+use std::fmt;
+
+impl<Static: StaticAtomSet> ::precomputed_hash::PrecomputedHash for Atom<Static> {
+    fn precomputed_hash(&self) -> u32 {
+        self.get_hash()
+    }
+}
+
+impl<'a, Static: StaticAtomSet> From<&'a Atom<Static>> for Atom<Static> {
+    fn from(atom: &'a Self) -> Self {
+        atom.clone()
+    }
+}
+
+impl<Static: StaticAtomSet> PartialEq<str> for Atom<Static> {
+    fn eq(&self, other: &str) -> bool {
+        &self[..] == other
+    }
+}
+
+impl<Static: StaticAtomSet> PartialEq<Atom<Static>> for str {
+    fn eq(&self, other: &Atom<Static>) -> bool {
+        self == &other[..]
+    }
+}
+
+impl<Static: StaticAtomSet> PartialEq<String> for Atom<Static> {
+    fn eq(&self, other: &String) -> bool {
+        &self[..] == &other[..]
+    }
+}
+
+impl<'a, Static: StaticAtomSet> From<&'a str> for Atom<Static> {
+    #[inline]
+    fn from(string_to_add: &str) -> Self {
+        Atom::from(Cow::Borrowed(string_to_add))
+    }
+}
+
+impl<Static: StaticAtomSet> From<String> for Atom<Static> {
+    #[inline]
+    fn from(string_to_add: String) -> Self {
+        Atom::from(Cow::Owned(string_to_add))
+    }
+}
+
+impl<Static: StaticAtomSet> fmt::Display for Atom<Static> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        <str as fmt::Display>::fmt(self, f)
+    }
+}
+
+impl<Static: StaticAtomSet> AsRef<str> for Atom<Static> {
+    fn as_ref(&self) -> &str {
+        &self
+    }
+}
+
+impl<Static: StaticAtomSet> Serialize for Atom<Static> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let string: &str = self.as_ref();
+        string.serialize(serializer)
+    }
+}
+
+impl<'a, Static: StaticAtomSet> Deserialize<'a> for Atom<Static> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'a>,
+    {
+        let string: String = Deserialize::deserialize(deserializer)?;
+        Ok(Atom::from(string))
+    }
+}