Auto merge of #231 - servo:nonzero, r=nox

Add the non-zero optimization to Atom

Author: bors-servo

Cargo.toml

@@ -22,7 +22,6 @@ lazy_static = "1"
 serde = "1"
 phf_shared = "0.8"
 new_debug_unreachable = "1.0"
-string_cache_shared = {path = "./shared", version = "0.3"}
 
 [[test]]
 name = "small-stack"

examples/simple.rs

@@ -3,12 +3,12 @@ extern crate string_cache;
 use string_cache::DefaultAtom;
 
 fn main() {
-
     let mut interned_stuff = Vec::new();
     let text = "here is a sentence of text that will be tokenised and interned and some repeated \
                 tokens is of text and";
     for word in text.split_whitespace() {
-        let seen_before = interned_stuff.iter()
+        let seen_before = interned_stuff
+            .iter()
             // We can use impl PartialEq<T> where T is anything string-like to compare to
             // interned strings to either other interned strings, or actual strings  Comparing two
             // interned strings is very fast (normally a single cpu operation).

integration-tests/build.rs

@@ -6,7 +6,16 @@ use std::path::Path;
 fn main() {
     string_cache_codegen::AtomType::new("TestAtom", "test_atom!")
         .atoms(&[
-            "a", "b", "address", "area", "body", "font-weight", "br", "html", "head", "id",
+            "a",
+            "b",
+            "address",
+            "area",
+            "body",
+            "font-weight",
+            "br",
+            "html",
+            "head",
+            "id",
         ])
         .write_to_file(&Path::new(&env::var("OUT_DIR").unwrap()).join("test_atom.rs"))
         .unwrap()

integration-tests/src/bench.rs

@@ -28,7 +28,7 @@ and cheap to move around, which isn't reflected in these tests.
 */
 use crate::TestAtom;
 
-use test::{Bencher, black_box};
+use test::{black_box, Bencher};
 
 // Just shorthand
 fn mk(x: &str) -> TestAtom {
@@ -142,10 +142,10 @@ macro_rules! bench_all (
     );
 );
 
-pub const longer_dynamic_a: &'static str
-    = "Thee Silver Mt. Zion Memorial Orchestra & Tra-La-La Band";
-pub const longer_dynamic_b: &'static str
-    = "Thee Silver Mt. Zion Memorial Orchestra & Tra-La-La Ban!";
+pub const longer_dynamic_a: &'static str =
+    "Thee Silver Mt. Zion Memorial Orchestra & Tra-La-La Band";
+pub const longer_dynamic_b: &'static str =
+    "Thee Silver Mt. Zion Memorial Orchestra & Tra-La-La Ban!";
 
 bench_all!([eq ne lt clone_string] for short_string = "e", "f");
 bench_all!([eq ne lt clone_string] for medium_string = "xyzzy01", "xyzzy02");
@@ -206,7 +206,7 @@ macro_rules! bench_rand ( ($name:ident, $len:expr) => (
     }
 ));
 
-bench_rand!(intern_rand_008,   8);
-bench_rand!(intern_rand_032,  32);
+bench_rand!(intern_rand_008, 8);
+bench_rand!(intern_rand_032, 32);
 bench_rand!(intern_rand_128, 128);
 bench_rand!(intern_rand_512, 512);

integration-tests/src/lib.rs

@@ -8,16 +8,16 @@
 // except according to those terms.
 
 #![cfg(test)]
-
 #![deny(warnings)]
 #![allow(non_upper_case_globals)]
-
 #![cfg_attr(feature = "unstable", feature(test))]
 
 extern crate string_cache;
 
-#[cfg(feature = "unstable")] extern crate test;
-#[cfg(feature = "unstable")] extern crate rand;
+#[cfg(feature = "unstable")]
+extern crate rand;
+#[cfg(feature = "unstable")]
+extern crate test;
 
 use std::thread;
 use string_cache::atom::StaticAtomSet;
@@ -157,32 +157,32 @@ macro_rules! assert_eq_fmt (($fmt:expr, $x:expr, $y:expr) => ({
 #[test]
 fn repr() {
     fn check(s: &str, data: u64) {
-        assert_eq_fmt!("0x{:016X}", Atom::from(s).unsafe_data, data);
+        assert_eq_fmt!("0x{:016X}", Atom::from(s).unsafe_data(), data);
     }
 
     fn check_static(s: &str, x: Atom) {
-        assert_eq_fmt!("0x{:016X}", x.unsafe_data, Atom::from(s).unsafe_data);
-        assert_eq!(0x2, x.unsafe_data & 0xFFFF_FFFF);
+        assert_eq_fmt!("0x{:016X}", x.unsafe_data(), Atom::from(s).unsafe_data());
+        assert_eq!(0x2, x.unsafe_data() & 0xFFFF_FFFF);
         // The index is unspecified by phf.
-        assert!((x.unsafe_data >> 32) <= TestAtomStaticSet::get().atoms.len() as u64);
+        assert!((x.unsafe_data() >> 32) <= TestAtomStaticSet::get().atoms.len() as u64);
     }
 
     // This test is here to make sure we don't change atom representation
     // by accident.  It may need adjusting if there are changes to the
     // static atom table, the tag values, etc.
 
     // Static atoms
-    check_static("a",       test_atom!("a"));
+    check_static("a", test_atom!("a"));
     check_static("address", test_atom!("address"));
-    check_static("area",    test_atom!("area"));
+    check_static("area", test_atom!("area"));
 
     // Inline atoms
-    check("e",       0x0000_0000_0000_6511);
-    check("xyzzy",   0x0000_797A_7A79_7851);
+    check("e", 0x0000_0000_0000_6511);
+    check("xyzzy", 0x0000_797A_7A79_7851);
     check("xyzzy01", 0x3130_797A_7A79_7871);
 
     // Dynamic atoms. This is a pointer so we can't verify every bit.
-    assert_eq!(0x00, Atom::from("a dynamic string").unsafe_data & 0xf);
+    assert_eq!(0x00, Atom::from("a dynamic string").unsafe_data() & 0xf);
 }
 
 #[test]
@@ -203,23 +203,32 @@ fn atom_macro() {
 
 #[test]
 fn match_atom() {
-    assert_eq!(2, match Atom::from("head") {
-        test_atom!("br") => 1,
-        test_atom!("html") | test_atom!("head") => 2,
-        _ => 3,
-    });
-
-    assert_eq!(3, match Atom::from("body") {
-        test_atom!("br") => 1,
-        test_atom!("html") | test_atom!("head") => 2,
-        _ => 3,
-    });
-
-    assert_eq!(3, match Atom::from("zzzzzz") {
-        test_atom!("br") => 1,
-        test_atom!("html") | test_atom!("head") => 2,
-        _ => 3,
-    });
+    assert_eq!(
+        2,
+        match Atom::from("head") {
+            test_atom!("br") => 1,
+            test_atom!("html") | test_atom!("head") => 2,
+            _ => 3,
+        }
+    );
+
+    assert_eq!(
+        3,
+        match Atom::from("body") {
+            test_atom!("br") => 1,
+            test_atom!("html") | test_atom!("head") => 2,
+            _ => 3,
+        }
+    );
+
+    assert_eq!(
+        3,
+        match Atom::from("zzzzzz") {
+            test_atom!("br") => 1,
+            test_atom!("html") | test_atom!("head") => 2,
+            _ => 3,
+        }
+    );
 }
 
 #[test]
@@ -240,29 +249,43 @@ fn ensure_as_ref() {
 fn test_ascii_lowercase() {
     assert_eq!(Atom::from("").to_ascii_lowercase(), Atom::from(""));
     assert_eq!(Atom::from("aZ9").to_ascii_lowercase(), Atom::from("az9"));
-    assert_eq!(Atom::from("The Quick Brown Fox!").to_ascii_lowercase(), Atom::from("the quick brown fox!"));
-    assert_eq!(Atom::from("JE VAIS À PARIS").to_ascii_lowercase(), Atom::from("je vais À paris"));
+    assert_eq!(
+        Atom::from("The Quick Brown Fox!").to_ascii_lowercase(),
+        Atom::from("the quick brown fox!")
+    );
+    assert_eq!(
+        Atom::from("JE VAIS À PARIS").to_ascii_lowercase(),
+        Atom::from("je vais À paris")
+    );
 }
 
 #[test]
 fn test_ascii_uppercase() {
     assert_eq!(Atom::from("").to_ascii_uppercase(), Atom::from(""));
     assert_eq!(Atom::from("aZ9").to_ascii_uppercase(), Atom::from("AZ9"));
-    assert_eq!(Atom::from("The Quick Brown Fox!").to_ascii_uppercase(), Atom::from("THE QUICK BROWN FOX!"));
-    assert_eq!(Atom::from("Je vais à Paris").to_ascii_uppercase(), Atom::from("JE VAIS à PARIS"));
+    assert_eq!(
+        Atom::from("The Quick Brown Fox!").to_ascii_uppercase(),
+        Atom::from("THE QUICK BROWN FOX!")
+    );
+    assert_eq!(
+        Atom::from("Je vais à Paris").to_ascii_uppercase(),
+        Atom::from("JE VAIS à PARIS")
+    );
 }
 
 #[test]
 fn test_eq_ignore_ascii_case() {
     assert!(Atom::from("").eq_ignore_ascii_case(&Atom::from("")));
     assert!(Atom::from("aZ9").eq_ignore_ascii_case(&Atom::from("aZ9")));
     assert!(Atom::from("aZ9").eq_ignore_ascii_case(&Atom::from("Az9")));
-    assert!(Atom::from("The Quick Brown Fox!").eq_ignore_ascii_case(&Atom::from("THE quick BROWN fox!")));
+    assert!(Atom::from("The Quick Brown Fox!")
+        .eq_ignore_ascii_case(&Atom::from("THE quick BROWN fox!")));
     assert!(Atom::from("Je vais à Paris").eq_ignore_ascii_case(&Atom::from("je VAIS à PARIS")));
     assert!(!Atom::from("").eq_ignore_ascii_case(&Atom::from("az9")));
     assert!(!Atom::from("aZ9").eq_ignore_ascii_case(&Atom::from("")));
     assert!(!Atom::from("aZ9").eq_ignore_ascii_case(&Atom::from("9Za")));
-    assert!(!Atom::from("The Quick Brown Fox!").eq_ignore_ascii_case(&Atom::from("THE quick BROWN fox!!")));
+    assert!(!Atom::from("The Quick Brown Fox!")
+        .eq_ignore_ascii_case(&Atom::from("THE quick BROWN fox!!")));
     assert!(!Atom::from("Je vais à Paris").eq_ignore_ascii_case(&Atom::from("JE vais À paris")));
 }