Move static sets to their own module

Author: SimonSapin

src/atom.rs

@@ -10,6 +10,7 @@
 #![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};
@@ -35,61 +36,6 @@ const LEN_MASK: u64 = 0xF0;
 const MAX_INLINE_LEN: usize = 7;
 const STATIC_SHIFT_BITS: usize = 32;
 
-/// A static `PhfStrSet`
-///
-/// This trait is implemented by static sets of interned strings generated using
-/// `string_cache_codegen`, and `EmptyStaticAtomSet` for when strings will be added dynamically.
-///
-/// It is used by the methods of [`Atom`] to check if a string is present in the static set.
-///
-/// [`Atom`]: struct.Atom.html
-pub trait StaticAtomSet: Ord {
-    /// Get the location of the static string set in the binary.
-    fn get() -> &'static PhfStrSet;
-    /// Get the index of the empty string, which is in every set and is used for `Atom::default`.
-    fn empty_string_index() -> u32;
-}
-
-/// A string set created using a [perfect hash function], specifically
-/// [Hash, Displace and Compress].
-///
-/// See the CHD document for the meaning of the struct fields.
-///
-/// [perfect hash function]: https://en.wikipedia.org/wiki/Perfect_hash_function
-/// [Hash, Displace and Compress]: http://cmph.sourceforge.net/papers/esa09.pdf
-pub struct PhfStrSet {
-    pub key: u64,
-    pub disps: &'static [(u32, u32)],
-    pub atoms: &'static [&'static str],
-    pub hashes: &'static [u32],
-}
-
-/// An empty static atom set for when only dynamic strings will be added
-#[derive(PartialEq, Eq, PartialOrd, Ord)]
-pub struct EmptyStaticAtomSet;
-
-impl StaticAtomSet for EmptyStaticAtomSet {
-    fn get() -> &'static PhfStrSet {
-        // The name is a lie: this set is not empty (it contains the empty string)
-        // but that’s only to avoid divisions by zero in rust-phf.
-        static SET: PhfStrSet = PhfStrSet {
-            key: 0,
-            disps: &[(0, 0)],
-            atoms: &[""],
-            // "" SipHash'd, and xored with u64_hash_to_u32.
-            hashes: &[0x3ddddef3],
-        };
-        &SET
-    }
-
-    fn empty_string_index() -> u32 {
-        0
-    }
-}
-
-/// Use this if you don’t care about static atoms.
-pub type DefaultAtom = Atom<EmptyStaticAtomSet>;
-
 /// Represents a string that has been interned.
 ///
 /// While the type definition for `Atom` indicates that it generic on a particular
@@ -277,10 +223,8 @@ impl<'a, Static: StaticAtomSet> From<Cow<'a, str>> for Atom<Static> {
                     phantom: PhantomData,
                 }
             } else {
-                let ptr: std::ptr::NonNull<Entry> = DYNAMIC_SET
-                    .lock()
-                    .unwrap()
-                    .insert(string_to_add, hash.g);
+                let ptr: std::ptr::NonNull<Entry> =
+                    DYNAMIC_SET.lock().unwrap().insert(string_to_add, hash.g);
                 let data = ptr.as_ptr() as u64;
                 debug_assert!(0 == data & TAG_MASK);
                 Atom {
@@ -516,29 +460,3 @@ fn inline_atom_slice_mut(x: &mut u64) -> &mut [u8] {
         slice::from_raw_parts_mut(data, len)
     }
 }
-
-// Some minor tests of internal layout here. See ../integration-tests for much
-// more.
-#[test]
-fn assert_sizes() {
-    use std::mem;
-    struct EmptyWithDrop;
-    impl Drop for EmptyWithDrop {
-        fn drop(&mut self) {}
-    }
-    let compiler_uses_inline_drop_flags = mem::size_of::<EmptyWithDrop>() > 0;
-
-    // Guard against accidental changes to the sizes of things.
-    assert_eq!(
-        mem::size_of::<DefaultAtom>(),
-        if compiler_uses_inline_drop_flags {
-            16
-        } else {
-            8
-        }
-    );
-    assert_eq!(
-        mem::size_of::<Option<DefaultAtom>>(),
-        mem::size_of::<DefaultAtom>(),
-    );
-}

src/lib.rs

@@ -105,7 +105,23 @@
 #![crate_type = "rlib"]
 #![cfg_attr(test, deny(warnings))]
 
-pub use crate::atom::{Atom, DefaultAtom, EmptyStaticAtomSet, PhfStrSet, StaticAtomSet};
-
 mod atom;
 mod dynamic_set;
+mod static_sets;
+
+pub use atom::Atom;
+pub use static_sets::{EmptyStaticAtomSet, PhfStrSet, StaticAtomSet};
+
+/// Use this if you don’t care about static atoms.
+pub type DefaultAtom = Atom<EmptyStaticAtomSet>;
+
+// Some minor tests of internal layout here.
+// See ../integration-tests for much more.
+
+/// Guard against accidental changes to the sizes of things.
+#[test]
+fn assert_sizes() {
+    use std::mem::size_of;
+    assert_eq!(size_of::<DefaultAtom>(), 8);
+    assert_eq!(size_of::<Option<DefaultAtom>>(), size_of::<DefaultAtom>(),);
+}

src/static_sets.rs

@@ -0,0 +1,64 @@
+// 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.
+
+/// A static `PhfStrSet`
+///
+/// This trait is implemented by static sets of interned strings generated using
+/// `string_cache_codegen`, and `EmptyStaticAtomSet` for when strings will be added dynamically.
+///
+/// It is used by the methods of [`Atom`] to check if a string is present in the static set.
+///
+/// [`Atom`]: struct.Atom.html
+pub trait StaticAtomSet: Ord {
+    /// Get the location of the static string set in the binary.
+    fn get() -> &'static PhfStrSet;
+    /// Get the index of the empty string, which is in every set and is used for `Atom::default`.
+    fn empty_string_index() -> u32;
+}
+
+/// A string set created using a [perfect hash function], specifically
+/// [Hash, Displace and Compress].
+///
+/// See the CHD document for the meaning of the struct fields.
+///
+/// [perfect hash function]: https://en.wikipedia.org/wiki/Perfect_hash_function
+/// [Hash, Displace and Compress]: http://cmph.sourceforge.net/papers/esa09.pdf
+pub struct PhfStrSet {
+    #[doc(hidden)]
+    pub key: u64,
+    #[doc(hidden)]
+    pub disps: &'static [(u32, u32)],
+    #[doc(hidden)]
+    pub atoms: &'static [&'static str],
+    #[doc(hidden)]
+    pub hashes: &'static [u32],
+}
+
+/// An empty static atom set for when only dynamic strings will be added
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub struct EmptyStaticAtomSet;
+
+impl StaticAtomSet for EmptyStaticAtomSet {
+    fn get() -> &'static PhfStrSet {
+        // The name is a lie: this set is not empty (it contains the empty string)
+        // but that’s only to avoid divisions by zero in rust-phf.
+        static SET: PhfStrSet = PhfStrSet {
+            key: 0,
+            disps: &[(0, 0)],
+            atoms: &[""],
+            // "" SipHash'd, and xored with u64_hash_to_u32.
+            hashes: &[0x3ddddef3],
+        };
+        &SET
+    }
+
+    fn empty_string_index() -> u32 {
+        0
+    }
+}