Move remaining usage of unstable features behind a unstable Cargo feature flag.

Without `--features unstable`:

* `Atom` is 16 bytes instead of 8. (It has a drop flag.)
* `ns!` and `atom!` are giant generated macros instead of plugins, and
so may increase compile time.

Author: SimonSapin

Cargo.toml

@@ -7,6 +7,7 @@ description = "A string interning library for Rust, developed as part of the Ser
 license = "MIT / Apache-2.0"
 repository = "https://github.com/servo/string-cache"
 documentation = "http://doc.servo.org/string_cache/"
+build = "build.rs"
 
 [lib]
 name = "string_cache"
@@ -20,6 +21,9 @@ doctest = false
 # See examples/event-log.
 log-events = ["rustc-serialize"]
 
+# Use unstable features to optimize space and time (memory and CPU usage).
+unstable = ["string_cache_plugin"]
+
 [dependencies]
 rand = "0"
 lazy_static = "0.1.10"
@@ -32,7 +36,12 @@ optional = true
 [dependencies.string_cache_plugin]
 path = "plugin"
 version = "0.1.1"
+optional = true
 
 [dependencies.string_cache_shared]
 path = "shared"
 version = "0.1.0"
+
+[build-dependencies.string_cache_shared]
+path = "shared"
+version = "0.1.0"

build.rs

@@ -0,0 +1,59 @@
+extern crate string_cache_shared;
+
+use string_cache_shared::{STATIC_ATOM_SET, ALL_NS, pack_static};
+
+use std::ascii::AsciiExt;
+use std::fs::File;
+use std::io::{BufWriter, Write};
+use std::path::Path;
+
+fn main() {
+    let path = Path::new(env!("OUT_DIR")).join("ns_macro_without_plugin.rs");
+    let mut file = BufWriter::new(File::create(&path).unwrap());
+    writeln!(file, r"#[macro_export]").unwrap();
+    writeln!(file, r"macro_rules! ns {{").unwrap();
+    writeln!(file, "(\"\") => {{ $crate::Namespace({}) }};", atom("")).unwrap();
+    for &(prefix, url) in ALL_NS {
+        if !prefix.is_empty() {
+            generate_combination("".to_owned(), prefix, url, &mut file);
+        }
+    }
+    writeln!(file, r"}}").unwrap();
+
+    writeln!(file, r"#[macro_export]").unwrap();
+    writeln!(file, r"macro_rules! atom {{").unwrap();
+    for &s in STATIC_ATOM_SET.iter() {
+        if is_ident(s) {
+            writeln!(file, r"( {} ) => {{ {} }};", s, atom(s)).unwrap();
+        }
+        writeln!(file, r"({:?}) => {{ {} }};", s, atom(s)).unwrap();
+    }
+    writeln!(file, r"}}").unwrap();
+}
+
+fn generate_combination(prefix1: String, suffix: &str, url: &str, file: &mut BufWriter<File>) {
+    if suffix.is_empty() {
+        writeln!(file, r"({:?}) => {{ $crate::Namespace({}) }};", prefix1, atom(url)).unwrap();
+        writeln!(file, r"( {} ) => {{ $crate::Namespace({}) }};", prefix1, atom(url)).unwrap();
+    } else {
+        let prefix2 = prefix1.clone();
+        generate_combination(prefix1 + &*suffix[..1].to_ascii_lowercase(), &suffix[1..], url, file);
+        generate_combination(prefix2 + &*suffix[..1].to_ascii_uppercase(), &suffix[1..], url, file);
+    }
+}
+
+fn atom(s: &str) -> String {
+    let data = pack_static(STATIC_ATOM_SET.get_index(s).unwrap() as u32);
+    format!("$crate::Atom {{ data: 0x{:x} }}", data)
+}
+
+fn is_ident(s: &str) -> bool {
+    let mut chars = s.chars();
+    !s.is_empty() && match chars.next().unwrap() {
+        'a'...'z' | 'A'...'Z' | '_' => true,
+        _ => false
+    } && chars.all(|c| match c {
+        'a'...'z' | 'A'...'Z' | '_' | '0'...'9' => true,
+        _ => false
+    })
+}

plugin/src/atom/mod.rs

@@ -71,15 +71,7 @@ pub fn expand_atom(cx: &mut ExtCtxt, sp: Span, tt: &[TokenTree]) -> Box<MacResul
 // Translate `ns!(HTML)` into `Namespace { atom: atom!("http://www.w3.org/1999/xhtml") }`.
 // The argument is ASCII-case-insensitive.
 pub fn expand_ns(cx: &mut ExtCtxt, sp: Span, tt: &[TokenTree]) -> Box<MacResult+'static> {
-    static ALL_NS: &'static [(&'static str, &'static str)] = &[
-        ("", ""),
-        ("html", "http://www.w3.org/1999/xhtml"),
-        ("xml", "http://www.w3.org/XML/1998/namespace"),
-        ("xmlns", "http://www.w3.org/2000/xmlns/"),
-        ("xlink", "http://www.w3.org/1999/xlink"),
-        ("svg", "http://www.w3.org/2000/svg"),
-        ("mathml", "http://www.w3.org/1998/Math/MathML"),
-    ];
+    use string_cache_shared::ALL_NS;
 
     fn usage() -> String {
         let ns_names: Vec<&'static str> = ALL_NS[1..].iter()

shared/lib.rs

@@ -48,6 +48,16 @@ pub enum UnpackedAtom {
 
 const STATIC_SHIFT_BITS: usize = 32;
 
+pub static ALL_NS: &'static [(&'static str, &'static str)] = &[
+    ("", ""),
+    ("html", "http://www.w3.org/1999/xhtml"),
+    ("xml", "http://www.w3.org/XML/1998/namespace"),
+    ("xmlns", "http://www.w3.org/2000/xmlns/"),
+    ("xlink", "http://www.w3.org/1999/xlink"),
+    ("svg", "http://www.w3.org/2000/svg"),
+    ("mathml", "http://www.w3.org/1998/Math/MathML"),
+];
+
 struct RawSlice {
     data: *const u8,
     len: usize,

src/atom/mod.rs

@@ -11,22 +11,19 @@
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-use std::cmp::max;
 use std::fmt;
 use std::mem;
 use std::ops;
 use std::ptr;
-use std::slice::bytes;
 use std::str;
-use std::rt::heap;
 use std::cmp::Ordering::{self, Equal};
-use std::hash::{self, Hash, SipHasher};
+use std::hash::{Hash, SipHasher, Hasher};
 use std::sync::Mutex;
 use std::sync::atomic::AtomicIsize;
 use std::sync::atomic::Ordering::SeqCst;
 
 use string_cache_shared::{self, UnpackedAtom, Static, Inline, Dynamic, STATIC_ATOM_SET,
-                          ENTRY_ALIGNMENT};
+                          ENTRY_ALIGNMENT, copy_memory};
 
 #[cfg(feature = "log-events")]
 use event::Event;
@@ -71,7 +68,11 @@ impl StringCache {
     }
 
     fn add(&mut self, string_to_add: &str) -> *mut StringCacheEntry {
-        let hash = hash::hash::<_, SipHasher>(&string_to_add);
+        let hash = {
+            let mut hasher = SipHasher::default();
+            string_to_add.hash(&mut hasher);
+            hasher.finish()
+        };
         let bucket_index = (hash & (self.buckets.len()-1) as u64) as usize;
         let mut ptr = self.buckets[bucket_index];
 
@@ -101,14 +102,11 @@ impl StringCache {
         }
 
         if should_add {
-            unsafe {
-                ptr = heap::allocate(
-                    mem::size_of::<StringCacheEntry>(),
-                    max(mem::align_of::<StringCacheEntry>(), ENTRY_ALIGNMENT)
-                ) as *mut StringCacheEntry;
-                ptr::write(ptr,
-                            StringCacheEntry::new(self.buckets[bucket_index], hash, string_to_add));
-            }
+            debug_assert!(mem::align_of::<StringCacheEntry>() >= ENTRY_ALIGNMENT);
+            let mut entry = Box::new(StringCacheEntry::new(
+                self.buckets[bucket_index], hash, string_to_add));
+            ptr = &mut *entry;
+            mem::forget(entry);
             self.buckets[bucket_index] = ptr;
             log!(Event::Insert(ptr as u64, String::from(string_to_add)));
         }
@@ -143,19 +141,21 @@ impl StringCache {
         debug_assert!(current != ptr::null_mut());
 
         unsafe {
-            ptr::read(ptr);
-            heap::deallocate(ptr as *mut u8,
-                mem::size_of::<StringCacheEntry>(),
-                max(mem::align_of::<StringCacheEntry>(), ENTRY_ALIGNMENT));
+            box_from_raw(ptr);
         }
 
         log!(Event::Remove(key));
     }
 }
 
+// Box::from_raw is not stable yet
+unsafe fn box_from_raw<T>(raw: *mut T) -> Box<T> {
+    mem::transmute(raw)
+}
+
 // NOTE: Deriving Eq here implies that a given string must always
 // be interned the same way.
-#[unsafe_no_drop_flag]  // See tests::atom_drop_is_idempotent
+#[cfg_attr(unstable, unsafe_no_drop_flag)]  // See tests::atom_drop_is_idempotent
 #[derive(Eq, Hash, PartialEq)]
 pub struct Atom {
     /// This field is public so that the `atom!()` macro can use it.
@@ -177,7 +177,7 @@ impl Atom {
                 let len = string_to_add.len();
                 if len <= string_cache_shared::MAX_INLINE_LEN {
                     let mut buf: [u8; 7] = [0; 7];
-                    bytes::copy_memory(string_to_add.as_bytes(), &mut buf);
+                    copy_memory(string_to_add.as_bytes(), &mut buf);
                     Inline(len as u8, buf)
                 } else {
                     Dynamic(STRING_CACHE.lock().unwrap().add(string_to_add) as *mut ())
@@ -325,9 +325,10 @@ mod bench;
 
 #[cfg(test)]
 mod tests {
+    use std::mem;
     use std::thread;
-    use super::Atom;
-    use string_cache_shared::{Static, Inline, Dynamic};
+    use super::{Atom, StringCacheEntry};
+    use string_cache_shared::{Static, Inline, Dynamic, ENTRY_ALIGNMENT, from_packed_dynamic};
 
     #[test]
     fn test_as_slice() {
@@ -491,7 +492,7 @@ mod tests {
     fn assert_sizes() {
         // Guard against accidental changes to the sizes of things.
         use std::mem;
-        assert_eq!(8, mem::size_of::<super::Atom>());
+        assert_eq!(if cfg!(unstable) { 8 } else { 16 }, mem::size_of::<super::Atom>());
         assert_eq!(48, mem::size_of::<super::StringCacheEntry>());
     }
 
@@ -553,8 +554,12 @@ mod tests {
     #[test]
     fn atom_drop_is_idempotent() {
         unsafe {
-            assert_eq!(::string_cache_shared::from_packed_dynamic(::std::mem::POST_DROP_U64), None);
+            assert_eq!(from_packed_dynamic(mem::POST_DROP_U64), None);
         }
     }
 
+    #[test]
+    fn string_cache_entry_alignment_is_sufficient() {
+        assert!(mem::align_of::<StringCacheEntry>() >= ENTRY_ALIGNMENT);
+    }
 }

src/lib.rs

@@ -10,12 +10,11 @@
 #![crate_name = "string_cache"]
 #![crate_type = "rlib"]
 
-#![feature(plugin, unsafe_no_drop_flag)]
-#![feature(slice_bytes, heap_api, hash_default)]
 #![deny(warnings)]
 #![cfg_attr(test, feature(test, filling_drop))]
 #![cfg_attr(bench, feature(rand))]
-#![plugin(string_cache_plugin)]
+#![cfg_attr(feature = "unstable", feature(unsafe_no_drop_flag, plugin))]
+#![cfg_attr(feature = "unstable", plugin(string_cache_plugin))]
 
 #[cfg(test)]
 extern crate test;
@@ -43,6 +42,9 @@ macro_rules! qualname (($ns:tt, $local:tt) => (
     }
 ));
 
+#[cfg(not(feature = "unstable"))]
+include!(concat!(env!("OUT_DIR"), "/ns_macro_without_plugin.rs"));
+
 #[cfg(feature = "log-events")]
 #[macro_use]
 pub mod event;

src/namespace.rs

@@ -37,30 +37,31 @@ impl QualName {
 #[cfg(test)]
 mod tests {
     use super::{Namespace, QualName};
+    use Atom;
 
     #[test]
     fn ns_macro() {
-        assert_eq!(ns!(""),     Namespace(atom!("")));
+        assert_eq!(ns!(""),     Namespace(Atom::from_slice("")));
 
-        assert_eq!(ns!(html),   Namespace(atom!("http://www.w3.org/1999/xhtml")));
-        assert_eq!(ns!(xml),    Namespace(atom!("http://www.w3.org/XML/1998/namespace")));
-        assert_eq!(ns!(xmlns),  Namespace(atom!("http://www.w3.org/2000/xmlns/")));
-        assert_eq!(ns!(xlink),  Namespace(atom!("http://www.w3.org/1999/xlink")));
-        assert_eq!(ns!(svg),    Namespace(atom!("http://www.w3.org/2000/svg")));
-        assert_eq!(ns!(mathml), Namespace(atom!("http://www.w3.org/1998/Math/MathML")));
+        assert_eq!(ns!(html),   Namespace(Atom::from_slice("http://www.w3.org/1999/xhtml")));
+        assert_eq!(ns!(xml),    Namespace(Atom::from_slice("http://www.w3.org/XML/1998/namespace")));
+        assert_eq!(ns!(xmlns),  Namespace(Atom::from_slice("http://www.w3.org/2000/xmlns/")));
+        assert_eq!(ns!(xlink),  Namespace(Atom::from_slice("http://www.w3.org/1999/xlink")));
+        assert_eq!(ns!(svg),    Namespace(Atom::from_slice("http://www.w3.org/2000/svg")));
+        assert_eq!(ns!(mathml), Namespace(Atom::from_slice("http://www.w3.org/1998/Math/MathML")));
 
-        assert_eq!(ns!(HtMl),   Namespace(atom!("http://www.w3.org/1999/xhtml")));
-        assert_eq!(ns!(xMl),    Namespace(atom!("http://www.w3.org/XML/1998/namespace")));
-        assert_eq!(ns!(XmLnS),  Namespace(atom!("http://www.w3.org/2000/xmlns/")));
-        assert_eq!(ns!(xLiNk),  Namespace(atom!("http://www.w3.org/1999/xlink")));
-        assert_eq!(ns!(SvG),    Namespace(atom!("http://www.w3.org/2000/svg")));
-        assert_eq!(ns!(mAtHmL), Namespace(atom!("http://www.w3.org/1998/Math/MathML")));
+        assert_eq!(ns!(HtMl),   Namespace(Atom::from_slice("http://www.w3.org/1999/xhtml")));
+        assert_eq!(ns!(xMl),    Namespace(Atom::from_slice("http://www.w3.org/XML/1998/namespace")));
+        assert_eq!(ns!(XmLnS),  Namespace(Atom::from_slice("http://www.w3.org/2000/xmlns/")));
+        assert_eq!(ns!(xLiNk),  Namespace(Atom::from_slice("http://www.w3.org/1999/xlink")));
+        assert_eq!(ns!(SvG),    Namespace(Atom::from_slice("http://www.w3.org/2000/svg")));
+        assert_eq!(ns!(mAtHmL), Namespace(Atom::from_slice("http://www.w3.org/1998/Math/MathML")));
     }
 
     #[test]
     fn qualname() {
         assert_eq!(QualName::new(ns!(""), atom!("")),
-            QualName { ns: ns!(""), local: atom!("") });
+            QualName { ns: ns!(""), local: Atom::from_slice("") });
         assert_eq!(QualName::new(ns!(XML), atom!(base)),
             QualName { ns: ns!(XML), local: atom!(base) });
     }