Update to build with latest rustc nightly

* Macro syntax changed (mandatory closing semicolon).
* Array sytanx changed (`[ty, ..n]` replaced by `[ty; n]`).
* Enums became namespaced.
* `proc()` syntax got replaced by `move ||`.
* `#[deriving(x)]` became deprected and got replaced by `#[derive(x)]`.
* Some APIs changed (around pointers, slices, vectors, hashes, locks, strings, threads).

Author: akosthekiss

macros/src/atom/mod.rs

@@ -139,4 +139,4 @@ macro_rules! qualname (($ns:tt, $local:tt) => (
         ns: ns!($ns),
         local: atom!($local),
     }
-))
+));

macros/src/lib.rs

@@ -25,18 +25,18 @@ use rustc::plugin::Registry;
 macro_rules! bail ( ($cx:expr, $sp:expr, $msg:expr) => ({
     $cx.span_err($sp, $msg);
     return ::syntax::ext::base::DummyResult::any($sp);
-}))
+}));
 
 macro_rules! bail_if ( ($e:expr, $cx:expr, $sp:expr, $msg:expr) => (
     if $e { bail!($cx, $sp, $msg) }
-))
+));
 
 macro_rules! expect ( ($cx:expr, $sp:expr, $e:expr, $msg:expr) => (
     match $e {
         Some(x) => x,
         None => bail!($cx, $sp, $msg),
     }
-))
+));
 
 mod atom;
 

shared/repr.rs

@@ -14,9 +14,9 @@
 #![allow(dead_code, unused_imports)]
 
 use core::{mem, raw, intrinsics};
-use core::option::{Option, Some, None};
-use core::ptr::RawPtr;
-use core::slice::{SlicePrelude, AsSlice};
+use core::option::Option::{self, Some, None};
+use core::ptr::PtrExt;
+use core::slice::{AsSlice, SliceExt};
 use core::slice::bytes;
 
 pub use self::UnpackedAtom::{Dynamic, Inline, Static};
@@ -35,7 +35,7 @@ pub enum UnpackedAtom {
     Dynamic(*mut ()),
 
     /// Length + bytes of string.
-    Inline(u8, [u8, ..7]),
+    Inline(u8, [u8; 7]),
 
     /// Index in static interning table.
     Static(u32),
@@ -91,7 +91,7 @@ impl UnpackedAtom {
             INLINE_TAG => {
                 let len = ((data & 0xf0) >> 4) as uint;
                 debug_assert!(len <= MAX_INLINE_LEN);
-                let mut buf: [u8, ..7] = [0, ..7];
+                let mut buf: [u8; 7] = [0; 7];
                 let src: &[u8] = mem::transmute(inline_atom_slice(&data));
                 bytes::copy_memory(buf.as_mut_slice(), src);
                 Inline(len as u8, buf)

src/atom/bench.rs

@@ -44,37 +44,37 @@ macro_rules! check_type (($name:ident, $x:expr, $p:pat) => (
             _ => panic!("atom has wrong type"),
         }
     }
-))
+));
 
 macro_rules! bench_tiny_op (($name:ident, $op:ident, $ctor_x:expr, $ctor_y:expr) => (
     #[bench]
     fn $name(b: &mut Bencher) {
         const n: uint = 1000;
-        let xs = Vec::from_elem(n, $ctor_x);
-        let ys = Vec::from_elem(n, $ctor_y);
+        let xs: Vec<_> = repeat($ctor_x).take(n).collect();
+        let ys: Vec<_> = repeat($ctor_y).take(n).collect();
 
         b.iter(|| {
             for (x, y) in xs.iter().zip(ys.iter()) {
                 black_box(x.$op(y));
             }
         });
     }
-))
+));
 
 macro_rules! bench_one (
-    (x_static   $x:expr, $y:expr) => (check_type!(check_type_x, $x, Static(..)));
-    (x_inline   $x:expr, $y:expr) => (check_type!(check_type_x, $x, Inline(..)));
-    (x_dynamic  $x:expr, $y:expr) => (check_type!(check_type_x, $x, Dynamic(..)));
-    (y_static   $x:expr, $y:expr) => (check_type!(check_type_y, $y, Static(..)));
-    (y_inline   $x:expr, $y:expr) => (check_type!(check_type_y, $y, Inline(..)));
-    (y_dynamic  $x:expr, $y:expr) => (check_type!(check_type_y, $y, Dynamic(..)));
-    (is_static  $x:expr, $y:expr) => (bench_one!(x_static  $x, $y) bench_one!(y_static  $x, $y));
-    (is_inline  $x:expr, $y:expr) => (bench_one!(x_inline  $x, $y) bench_one!(y_inline  $x, $y));
-    (is_dynamic $x:expr, $y:expr) => (bench_one!(x_dynamic $x, $y) bench_one!(y_dynamic $x, $y));
-
-    (eq $x:expr, $_y:expr) => (bench_tiny_op!(eq_x_1000, eq, $x, $x));
-    (ne $x:expr, $y:expr)  => (bench_tiny_op!(ne_x_1000, ne, $x, $y));
-    (lt $x:expr, $y:expr)  => (bench_tiny_op!(lt_x_1000, lt, $x, $y));
+    (x_static   $x:expr, $y:expr) => (check_type!(check_type_x, $x, Static(..)););
+    (x_inline   $x:expr, $y:expr) => (check_type!(check_type_x, $x, Inline(..)););
+    (x_dynamic  $x:expr, $y:expr) => (check_type!(check_type_x, $x, Dynamic(..)););
+    (y_static   $x:expr, $y:expr) => (check_type!(check_type_y, $y, Static(..)););
+    (y_inline   $x:expr, $y:expr) => (check_type!(check_type_y, $y, Inline(..)););
+    (y_dynamic  $x:expr, $y:expr) => (check_type!(check_type_y, $y, Dynamic(..)););
+    (is_static  $x:expr, $y:expr) => (bench_one!(x_static  $x, $y); bench_one!(y_static  $x, $y););
+    (is_inline  $x:expr, $y:expr) => (bench_one!(x_inline  $x, $y); bench_one!(y_inline  $x, $y););
+    (is_dynamic $x:expr, $y:expr) => (bench_one!(x_dynamic $x, $y); bench_one!(y_dynamic $x, $y););
+
+    (eq $x:expr, $_y:expr) => (bench_tiny_op!(eq_x_1000, eq, $x, $x););
+    (ne $x:expr, $y:expr)  => (bench_tiny_op!(ne_x_1000, ne, $x, $y););
+    (lt $x:expr, $y:expr)  => (bench_tiny_op!(lt_x_1000, lt, $x, $y););
 
     (intern $x:expr, $_y:expr) => (
         #[bench]
@@ -122,7 +122,7 @@ macro_rules! bench_one (
             });
         }
     );
-)
+);
 
 macro_rules! bench_all (
     ([ $($which:ident)+ ] for $name:ident = $x:expr, $y:expr) => (
@@ -135,61 +135,62 @@ macro_rules! bench_all (
             use collections::vec::Vec;
             use test::{Bencher, black_box};
             use std::string::ToString;
+            use std::iter::repeat;
 
             use atom::Atom;
             use atom::repr::{Static, Inline, Dynamic};
 
             use super::mk;
 
             $(
-                bench_one!($which $x, $y)
+                bench_one!($which $x, $y);
             )+
         }
     );
-)
+);
 
 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")
+bench_all!([eq ne lt clone_string] for short_string = "e", "f");
+bench_all!([eq ne lt clone_string] for medium_string = "xyzzy01", "xyzzy02");
 bench_all!([eq ne lt clone_string]
-    for longer_string = super::longer_dynamic_a, super::longer_dynamic_b)
+    for longer_string = super::longer_dynamic_a, super::longer_dynamic_b);
 
 bench_all!([eq ne intern as_slice clone is_static lt]
-    for static_atom = atom!(a), atom!(b))
+    for static_atom = atom!(a), atom!(b));
 
 bench_all!([intern as_slice clone is_inline]
-    for short_inline_atom = mk("e"), mk("f"))
+    for short_inline_atom = mk("e"), mk("f"));
 
 bench_all!([eq ne intern as_slice clone is_inline lt]
-    for medium_inline_atom = mk("xyzzy01"), mk("xyzzy02"))
+    for medium_inline_atom = mk("xyzzy01"), mk("xyzzy02"));
 
 bench_all!([intern as_slice clone is_dynamic]
-    for min_dynamic_atom = mk("xyzzy001"), mk("xyzzy002"))
+    for min_dynamic_atom = mk("xyzzy001"), mk("xyzzy002"));
 
 bench_all!([eq ne intern as_slice clone is_dynamic lt]
-    for longer_dynamic_atom = mk(super::longer_dynamic_a), mk(super::longer_dynamic_b))
+    for longer_dynamic_atom = mk(super::longer_dynamic_a), mk(super::longer_dynamic_b));
 
 bench_all!([intern as_slice clone is_static]
-    for static_at_runtime = mk("a"), mk("b"))
+    for static_at_runtime = mk("a"), mk("b"));
 
 bench_all!([ne lt x_static y_inline]
-    for static_vs_inline  = atom!(a), mk("f"))
+    for static_vs_inline  = atom!(a), mk("f"));
 
 bench_all!([ne lt x_static y_dynamic]
-    for static_vs_dynamic = atom!(a), mk(super::longer_dynamic_b))
+    for static_vs_dynamic = atom!(a), mk(super::longer_dynamic_b));
 
 bench_all!([ne lt x_inline y_dynamic]
-    for inline_vs_dynamic = mk("e"), mk(super::longer_dynamic_b))
+    for inline_vs_dynamic = mk("e"), mk(super::longer_dynamic_b));
 
 macro_rules! bench_rand ( ($name:ident, $len:expr) => (
     #[bench]
     fn $name(b: &mut Bencher) {
         use std::{str, rand};
-        use std::slice::{SlicePrelude, AsSlice};
+        use std::slice::{AsSlice, SliceExt};
         use std::rand::Rng;
 
         let mut gen = rand::weak_rng();
@@ -200,19 +201,19 @@ macro_rules! bench_rand ( ($name:ident, $len:expr) => (
             // I measured the overhead of random string generation
             // as about 3-12% at one point.
 
-            let mut buf: [u8, ..$len] = [0, ..$len];
+            let mut buf: [u8; $len] = [0; $len];
             gen.fill_bytes(buf.as_mut_slice());
             for n in buf.iter_mut() {
                 // shift into printable ASCII
                 *n = (*n % 0x40) + 0x20;
             }
-            let s = unsafe { str::raw::from_utf8(buf.as_slice()) };
+            let s = unsafe { str::from_utf8(buf.as_slice()).unwrap() };
             black_box(Atom::from_slice(s));
         });
     }
-))
+));
 
-bench_rand!(intern_rand_008,   8)
-bench_rand!(intern_rand_032,  32)
-bench_rand!(intern_rand_128, 128)
-bench_rand!(intern_rand_512, 512)
+bench_rand!(intern_rand_008,   8);
+bench_rand!(intern_rand_032,  32);
+bench_rand!(intern_rand_128, 128);
+bench_rand!(intern_rand_512, 512);

src/atom/mod.rs

@@ -15,24 +15,27 @@ use phf::OrderedSet;
 use xxhash::XXHasher;
 
 use core::fmt;
+use core::iter::RandomAccessIterator;
 use core::mem;
 use core::ptr;
 use core::slice::bytes;
 use core::str;
-use core::atomic::{AtomicInt, SeqCst};
 use alloc::heap;
 use alloc::boxed::Box;
 use collections::string::String;
-use collections::hash::{Hash, Hasher};
+use std::cmp::Ordering::{self, Equal};
+use std::hash::{Hash, Hasher};
 use std::sync::Mutex;
+use std::sync::atomic::AtomicInt;
+use std::sync::atomic::Ordering::SeqCst;
 
 use self::repr::{UnpackedAtom, Static, Inline, Dynamic};
 
 #[cfg(feature = "log-events")]
 use event;
 
 #[cfg(not(feature = "log-events"))]
-macro_rules! log (($e:expr) => (()))
+macro_rules! log (($e:expr) => (()));
 
 #[path="../../shared/repr.rs"]
 pub mod repr;
@@ -45,7 +48,7 @@ static static_atom_set: OrderedSet<&'static str> = static_atom_set!();
 
 struct StringCache {
     hasher: XXHasher,
-    buckets: [*mut StringCacheEntry, ..4096],
+    buckets: [*mut StringCacheEntry; 4096],
 }
 
 lazy_static! {
@@ -59,6 +62,8 @@ struct StringCacheEntry {
     string: String,
 }
 
+unsafe impl Send for *mut StringCacheEntry { }
+
 impl StringCacheEntry {
     fn new(next: *mut StringCacheEntry, hash: u64, string_to_add: &str) -> StringCacheEntry {
         StringCacheEntry {
@@ -161,7 +166,7 @@ impl StringCache {
 // NOTE: Deriving Eq here implies that a given string must always
 // be interned the same way.
 #[unsafe_no_drop_flag]
-#[deriving(Eq, Hash, PartialEq)]
+#[derive(Eq, Hash, PartialEq)]
 pub struct Atom {
     /// This field is public so that the `atom!()` macro can use it.
     /// You should not otherwise access this field.
@@ -180,17 +185,17 @@ impl Atom {
             None => {
                 let len = string_to_add.len();
                 if len <= repr::MAX_INLINE_LEN {
-                    let mut buf: [u8, ..7] = [0, ..7];
+                    let mut buf: [u8; 7] = [0; 7];
                     bytes::copy_memory(buf.as_mut_slice(), string_to_add.as_bytes());
                     Inline(len as u8, buf)
                 } else {
-                    Dynamic(STRING_CACHE.lock().add(string_to_add) as *mut ())
+                    Dynamic(STRING_CACHE.lock().unwrap().add(string_to_add) as *mut ())
                 }
             }
         };
 
         let data = unsafe { unpacked.pack() };
-        log!(event::Intern(data))
+        log!(event::Intern(data));
         Atom { data: data }
     }
 
@@ -199,8 +204,7 @@ impl Atom {
             match self.unpack() {
                 Inline(..) => {
                     let buf = repr::inline_orig_bytes(&self.data);
-                    debug_assert!(str::is_utf8(buf));
-                    str::from_utf8_unchecked(buf)
+                    str::from_utf8(buf).unwrap()
                 },
                 Static(idx) => *static_atom_set.iter().idx(idx as uint).expect("bad static atom"),
                 Dynamic(entry) => {
@@ -235,15 +239,15 @@ impl Drop for Atom {
     fn drop(&mut self) {
         // Out of line to guide inlining.
         fn drop_slow(this: &mut Atom) {
-            STRING_CACHE.lock().remove(this.data);
+            STRING_CACHE.lock().unwrap().remove(this.data);
         }
 
         unsafe {
             match repr::from_packed_dynamic(self.data) {
                 // We use #[unsafe_no_drop_flag] so that Atom will be only 64
                 // bits.  That means we need to ignore a NULL pointer here,
                 // which represents a value that was moved out.
-                Some(entry) if entry.is_not_null() => {
+                Some(entry) if !entry.is_null() => {
                     let entry = entry as *mut StringCacheEntry;
                     if (*entry).ref_count.fetch_sub(1, SeqCst) == 1 {
                         drop_slow(self);
@@ -295,7 +299,7 @@ mod tests {
     use core::prelude::*;
 
     use std::fmt;
-    use std::task::spawn;
+    use std::thread::Thread;
     use super::Atom;
     use super::repr::{Static, Inline, Dynamic};
 
@@ -325,7 +329,7 @@ mod tests {
             $t => (),
             _ => panic!("atom has wrong type"),
         }
-    ))
+    ));
 
     #[test]
     fn test_types() {
@@ -423,10 +427,10 @@ mod tests {
         let y = $y;
         if x != y {
             panic!("assertion failed: {} != {}",
-                format_args!(fmt::format, $fmt, x).as_slice(),
-                format_args!(fmt::format, $fmt, y).as_slice());
+                format_args!($fmt, x),
+                format_args!($fmt, y));
         }
-    }))
+    }));
 
     #[test]
     fn repr() {
@@ -468,7 +472,7 @@ mod tests {
     #[test]
     fn test_threads() {
         for _ in range(0u32, 100u32) {
-            spawn(proc() {
+            Thread::spawn(move || {
                 let _ = Atom::from_slice("a dynamic string");
                 let _ = Atom::from_slice("another string");
             });

src/event.rs

@@ -33,4 +33,4 @@ pub fn log(e: Event) {
     LOG.lock().push(e);
 }
 
-macro_rules! log (($e:expr) => (::event::log($e)))
+macro_rules! log (($e:expr) => (::event::log($e)));

src/lib.rs

@@ -10,7 +10,7 @@
 #![crate_name = "string_cache"]
 #![crate_type = "rlib"]
 
-#![feature(phase, macro_rules, default_type_params, globs)]
+#![feature(phase, macro_rules, default_type_params, globs, old_orphan_check)]
 #![no_std]
 
 #[phase(plugin, link)]